Upload
brett-george
View
270
Download
5
Embed Size (px)
Citation preview
1
Chap. 5 Pointers and Arrays
5.3 Pointers and Arrays
5.4 Address Arithmetic
5.5 Character Pointers and Functions
5.6 Pointer Arrays; Pointers to Pointers
5.7 Multidimensional Arrays
5.8 Initialization of Pointer Arrays
5.9 Pointers vs Multi-dimensional Arrays
5.10 Command-line Arguments: main(int argc, *argv[])
5.11 Pointers to Functions
5.12 Complicated Declarations + Summary of Basic Declarations
6.7 typedef – first visit
System-oriented Programming, B. Hirsbrunner, diuf.unifr.ch/pai/sp, Lecture 6 – 24 March 2015kr5: Pointers and Arrays (~90') + exercises: ~90'
2
*** 5.3 Pointers and Arrays, 5.4 Address Arithmetic ***
a
The name of this array is “a” and its value is equivalent to the address of its first element: &a[0].
a+2
p+3
a+i points to the i-th element beyond a.
p+i points to the i-th element beyond p.
As p is a variable, p=a or ++p are legal;but as an array name is not a variable, expression like a=p or ++a are illegal !
p
int *p=a;
a[3]
a[1]
a[0]
a[2]
int a[4];
The declaration int a[4]; defines an array of size 4, that is, a block of 4 consecutive variables of type int, named a[0], a[1], a[2], a[3].
Tricky: •p-a is legal, but not p+a !Reminder:•if p is a generic pointer, i.e. void *p,the only defined operation is the back and forth casting to any other type of pointers.
come back to this slide if you are lost with pointers and arrays
3
5.5 Character Pointers and Functions
Within the called function, this array name becomes a local pointer variable!
When an array name a is passed to a function, what is passed is the address of a's first element, i.e. &a[0].
That means:
•as a formal parameter in a function definition, char a[] and char *p are equivalent :
int f(char a[]);
int f(char *p);
•and in both cases, the following calls will work:f(a); // char a[] = "hello";f(p); // char *p = a; //same result as previous callf("hello"); // constant string ! //-–- crash if f's body write to a cell of the //––– constant string
Let be the prototype: int f(char a[]);
"Proof": next slide
4
• in (1) 'a' is an immutable pointer to
a mutable string• in (2) 'p' is a mutable pointer to the
same object as 'a'• in (3) 'q' is a mutable pointer to
a possibly immutable string• in (7) "hello" is an immutable string
A "Proof" : a test program and its function frames
/* Return length of string s */int strlen(char s[]) { int n;
for (n = 0; *s != '\0'; s++) n++; return n;}
void main() { (0) int i1, i2, i3, i4;(1) char a[] = "hello";(2) char *p = a;(3) char *q = "hello";
(4) i1 = strlen(a);(5) i2 = strlen(p);(6) i3 = strlen(q);(7) i4 = strlen("hello"); }
‘o’
‘l’
‘l’’e'
'\0'
'h'
constant string(sdh segment)
(7)
strlen's frame(stack segment)
(4), (5)
s
n
strlen's frame(stack segment)
(7)
s
n
‘o’
‘l’
‘l’
'\0'
mutable string(sdh segment)
(1), (2)
‘e’
'h'
‘o’
‘l’
‘l’’e'
'\0'
'h'
possiblyconstant string(sdh segment)
(3)
strlen's frame(stack segment)
(6)
s
n
a: q
p
a:
q
i1
i3
i2
main's frame(stack segment)
(0) - (3)
i4
psdh stands for stack, data or heap(it is up to the compiler or the runtime to decide)
5
5.6 Pointer Arrays; Pointers to Pointers
Since pointers are variables themselves, they can be stored in arrays just as other variables can.
Example: Design a program that will sort a set of text lines into alphabetic order.
First Ideade\0
jk\0
abc\0
de\0
jk\0
abc\0
The sorting process has three steps• Read all the lines of input• Sort them• Print them in order
Complete solution• See pp. 107-110
(will not be discussed in this course)
Second Ideade\0jk\0abc\0
de\0jk\0abc\0
6
5.7 Multidimensional Arrays + 5.8 Initialization of Pointer Arrays
Array definitionchar a[2]; // a is an array[2] of char, // i.e. a constant pointer to an array[2] of charchar a[2][3]; // a is an array[2] of 'array[3] of char', // i.e. a matrix of 2 rows and 3 columns
Array definition with initializationchar a[2] = {'a','b'};char a[2][3] = {{'a','b','c'}, {'d','e','f'}};
char a[2][3];
7
5.9 Pointers vs. Multi-dimensional Arrays
Trickychar *ap[]; // ap is an array[] of pointer to char; char (*pa)[]; // pa is a pointer to an array[] of char;char aa[][8]; // aa is an array[] of array[8] of char;
Two Examples
8
#include <stdio.h>/* echo command-line arguments; 1st version */int main(int argc, char *argv[]){ int i; for (i = 1; i < argc; i++)
printf("%s%s", argv[i], (i < argc-1) ? " " : ""); printf("\n"); return 0;}
*** 5.10 Command-Line Arguments: %echo hello ***
stack and data segments just after the initialization of main(c,*v[]), called by %echo hello
NULLi
c
main's frame(stack segment)
$main
2
kr115_1
Assume the binary code is saved in the file 'echo'
(A)(data segment)
*(v+2)
*v
*(v+1)
v[0]
v[1]
v[2]
v
v
(B)(data segment)
v[0][0]
v[0][1]
‘h’
‘o’
‘e’
‘c’
'\0'
v[0]
v[1][0]
v[1][1]
’\0'
‘l’
‘l’
‘h’
‘e’
’o'
(C)(data segment)
v[1]
argv is an array of pointer to char.By convention argv is NULL-terminated, and the objects pointed by argv[i] are strings
9
Reminder : Arithmetic, Precedence and Associativity
Pointer arithmetic is well defined: v+1, ++v
If v is a pointer then the item pointed by v can be named by *v and v[0];i.e. the value of v is equal to *v's address; and the value of *v is equal to v[0][0]'s address
[] has higher precedence than *i.e. *v[] is equivalent to *(v[])
Associativity of [] is left to righti.e. v[][] is equivalent to (v[])[]
* and ++ have same precedence, but are evaluated from right to left:
*++v is equivalent to *(++v)++*v is equivalent to ++(*v)
10
Navigation through (A)
Typical Usage
for (i=0; v[i] != '\0', ++i) {…}
while ((++v)[0] != '\0') {…}
1. v[0] // dereferenced with the index [0]
a. v[0], v[1], v[2], … or v[++i]b. v[0], (v+1)[0], (v+2)[0], … or (++v)[0]
RemarkWith expression like *++v, be aware that the original value of v will be lost
2. *v // dereferenced with the operator *
a. *v, *(v+1), *(v+2), … or *++v
11
Navigation through (B)
1_2. *v[0] // double dereferenced, first with the index [0], then with the operator *a. *v[0], *(v[0]+1), *(v[0]+2),… or *++v[0]
1_1. v[0][0] // double dereferenced with the indexes [0] and [0]a. v[0][0], v[0][1], v[0][2],… or v[0][++i]b. v[0][0], (v[0]+1)[0], (v[0]+2)[0],… or (++v[0])[0]
2_1. (*v)[0] // double dereferenced, first with the operator *, then with the index [0] a. (*v)[0], (*v)[1], (*v)[2],… or (*v)[++i]b. (*v)[0], (*v+1)[0], (*v+2)[0],… or (++*v)[0]
2_2. **v // double dereferenced with the operator *a. **v, *(*v+1), *(*v+2),… or *++*v
Usage (see kr117, line command 'find'): Navigation through B0, C0, … and X1, X2, …while (--argc > 0 && (*++argv)[0] == '-') while (c = *++argv[0]) // same as (c=*++argv[0]) != '\0'
If you are lost, don't panic: draw a picture!
12
5.10 Command-Line Arguments: find [-nx] pattern
Synopsis find [-nx] <pattern>
DescriptionThe command 'find' prints all lines that match pattern, with the options:
• -x: for "except", signaling the inversion (print all lines which don't contain the pattern)• -n: for "number", to request line numbering
main(int argc, char *argv[]) {...}
RemarkThe complete program, which can be found in kr117, is very interesting as it contains a standard navigation through the argument 'char *argv[]' to find the options –x, -n, -xn, -nx:
while (--argc>0 && (*++argv)[0] == '-') while (c = *++argv[0]) switch (c) { case 'x': ... case –n': ... default: ... }
We will come back to this program in the Series of exercises !
13
5.11 Pointers to Functions
Prototypechar *f(); // f is a constant pointer to a fct with no arg. // and returning a pointer to a variable of type char // in short: f is a function returning a pointer to char
char (*f)(); // f is a variable of type pointer to a fct with no arg.
// and returning a value of type char
// in short: f is a pointer to a function returning a char
RemarkThis is similar to the expressions *a[] and (*a)[]
Example#include <stdio.h>int f(int p(int), int n) {return p(n);}int g(int (*p)(int), int n) {return p(n);}int h1(int n) {return n+1;}int h2(int n) {return n+2;}main() { printf("%d %d\n", f(h1,10), g(h2,10)); }
14
*** Summary of Basic Declarations ***
Basic typeschar c; // c is a variable of type char // in short: c is a charchar *c; // c is a variable of type pointer to char // in short: c is a pointer to char
Array and functionchar a[5]; // a is a constant pointer to an array[5] of char // in short: a is an array[5] of charchar f(); // f is a constant pointer to a fct with no arg. and // returning a char // in short: f is a function returning a char
Pointerschar *a[5]; // a is an array[5] of pointer to char;char (*a)[5]; // a is pointer to an array[5] of char,
char *f(); // f is a function returning a pointer to charchar (*f)(); // f is a pointer to a function returning a char
void f(char a[2]); // a is a pointer to an array[2] of charvoid f(char *a); // a is a pointer to a charvoid f(char a[]); // dito !!! // hint: in f's body, 'a' is a variable pointer
come back to this slide if you are lost with pointers, arrays or functions
15
5.12 Complicated Declarations
16
6.7 typedef – first visit
Examples of declarations
typedef int length_t; // types int (old) and length_t (new) are synonyms
typedef char *string_t; // string_t is a new type, synonym to type char *
typedef int (*fct_t)(int); // fct_t is a new type, synonym to a 'pointer to a function
// with one argument of type int and returning an int'
Examples of usage
length_t size;
string_t str, a[], f(string_t);
fct_t g;