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;