Pointers. Cedric Saule

Transcription

1 Pointers Cedric Saule

2 Variables and memory Each variable needs to be stored in memory. Memory is made of plenty cells of 8 bits (1 Byte) A ''char'' is stored in 1 cell, a ''short'' is stored in 2 cells We can access to a variable by two ways : Adress of the first cell. Variable name. 208 Adress of the cell char mychar = 16; 16 Value of the cell (8bits) 2

3 Pointers and variables 208 Adress of the cell &mychar 16 Value of the cell (8bits) mychar 208 Adress of the cell 16 Value of the cell (8bits) char mychar = 16; 567 Adress of the cell 208 Value of the cell (8bits) char* pchar; pchar = &mychar; Pointer is a variable which value is the variable adress. 3

4 Pointers and variables long mylong = ; long* plong; plong = &mylong; Only the first cell is referenced in a pointer. Cells are contiguous in memory. We accessed to the adress by the ''&'' operator. We accessed to the pointed value by the ''*'' 4 operator.

5 Pointers and pointed values 208 Adress of the cell 16 Value of the cell (8bits) char mychar = 16; 567 Adress of the cell 208 Value of the cell (8bits) char* pchar = &mychar; printf(''value %d\n'', mychar); printf(''reference %d\n'', &mychar); printf(''pointer %d\n'', pchar); printf(''pointed value %d\n'', *pchar); Value 16 Reference 208 Pointer 208 Pointed value 16 5

6 Pointers and pointed values 208 Adress of the cell 32 Value of the cell (8bits) char mychar = 32; 567 Adress of the cell 208 Value of the cell (8bits) char* pchar = &mychar; printf(''value %d\n'', mychar); printf(''reference %d\n'', &mychar); printf(''pointer %d\n'', pchar); printf(''pointed value %d\n'', *pchar); mychar = 32; printf(''value %d\n'', mychar); printf(''reference %d\n'', &mychar); printf(''pointer %d\n'', pchar); printf(''pointed value %d\n'', *pchar); Value 16 Reference 208 Pointer 208 Pointed value 16 Value 32 Reference 208 Pointer 208 Pointed value 32 6

7 Pointers and pointed values 208 Adress of the cell 21 Value of the cell (8bits) char mychar = 21; 567 Adress of the cell 208 Value of the cell (8bits) char* pchar = &mychar; printf(''value %d\n'', mychar); printf(''reference %d\n'', &mychar); printf(''pointer %d\n'', pchar); printf(''pointed value %d\n'', *pchar); *pchar = 21; printf(''value %d\n'', mychar); printf(''reference %d\n'', &mychar); printf(''pointer %d\n'', pchar); printf(''pointed value %d\n'', *pchar); Value 16 Reference 208 Pointer 208 Pointed value 16 Value 21 Reference 208 Pointer 208 Pointed value 21 7

8 Pointers and functions In language C, the variables are passed by value. It is the same with pointers but what is the passed value void addone(int a, int* b) { printf(''value a = %d\n'', a); printf(''value b = %d\n'', b); printf(''pointed value b = %d\n'', *b); (*b)++; printf(''pointed value b = %d\n\n'', *b); b = &a; printf(''value a = %d\n'', a); printf(''value b = %d\n'', b); printf(''pointed value b = %d\n\n'', *b); } int main() { int x = 3; int y = ; int* p = &x; printf(''value x = %d\n'', x); printf(''value y = %d\n'', y); printf(''adress x = %d\n'', &x); printf(''adress y = %d\n'', &y); printf(''value p = %d\n\n'', p); addone(y, p); printf(''value %d\n'', x); printf(''value %d\n'', y); printf(''adress %d\n'', &x); printf(''adress %d\n'', &y); printf(''value %d\n'', p); return 0;} Value x = 3 Value y = Adress x = Adress y = Value p = Value a = Value b = Pointed value b = 3 Pointed value b = 4 Value a = Value b = Pointed value b = Value x = 4 Value y = Adress x = 8 Adress y = Value p =

9 What happened Pointers and functions Main x y p 9

10 What happened Pointers and functions x Main 3 a addone Local copy of ''y'' Same value Different local adress y p b Local copy of ''p'' Same value Different local adress 10

11 What happened Pointers and functions Main x y p a b b addone Local copy of ''y'' Same value Different local adress Local copy of ''p'' Same value Different local adress Local copy of ''p'' modifies the value in the pointed cell. But the pointed cell is not local! Main x y p 11

12 What happened Pointers and functions Main x y p a b b addone Local copy of ''y'' Same value Different local adress Local copy of ''p'' Same value Different local adress Local copy of ''p'' modifies the value in the pointed cell. But the pointed cell is not local! Main x y p a b Local copy of ''p'' points the local adress of ''a'' 12

13 What happened Pointers and functions Main x y p a b b a b addone Local copy of ''y'' Same value Different local adress Local copy of ''p'' Same value Different local adress Local copy of ''p'' modifies the value in the pointed cell. But the pointed cell is not local! Local copy of ''p'' points the local adress of ''a'' x y Main p Outside the function, ''b'', the copy of ''p'', is destroyed and of course ''p'' is unchanged. 13

14 What happened Pointers and functions Main x y p addone Main x y p So, the functions' arguments in C are really passed by values. But some values have a non-local meaning. 14

15 Pointers and functions Of course the adress can be given directly as a parameter. void addone(int a, int* b) { (*b)++; b = &a;} int main() { int x = 3; int y = ; addone(y, &x); return 0;} Give as parameter the adress of ''x'' to the local pointer in the function.

16 Pointers and functions To modify a pointer inside a function, we create a pointer of pointer. int x = 5; int* y = &x; /* Contains the adress of x. */ int** z = &y; /* Contains the adress of y. */ Another problem : int* foo() { } int x = 5; int* p = &x; return p; int main() { int* myp; myp = foo(); printf(''value = %d\n'', (*myp)) return 0;} Local value in the function foo. The value is lost outside the foo function, ''myp'' is erratic! 16

17 Pointers and functions To make it possible, we need a permanent value of the pointer dynamic allocation! int* p = (int *) malloc(sizeof(int)); Transtyping from void* Memory Allocation Size of reserved memory We create an anonymous space in memory. We specify the size allocated. We affect it to a compatible variable. 17

18 Pointers and functions Dynamically allocated memory has to be explicitely freed. int* p = malloc(sizeof(int)); free(p); The convention if poiter does not point to something is that its value be NULL. #define NULL ((void *) 0) in <stddef.h> Only no ''NULL'' value can be freed. 18

19 Pointers and types As pointers indicate the adress of the pointed variable, they all have the same size. The compiler needs to know the number of pointed cells, that means the type. So, we can define anonymous pointer which size will be indicated later ''void*''. ''void*'' is compatible with all pointers types. 19

20 Functions and adresses In C, we cannot work with a variable which type is a function (what would be its size ) But we can work with the adress of a function : float myfunction(int x, double y) { } type : function's adress which arguments are ''int'' and ''double'' et return ''float''. value : adress where myfunction begins is not a lvalue (not contained by something) So we can legally define : float (*pfunc)(int n, double y); pfunc = myfunction; float (pfunc)(3, 3.5); /* Calls myfunction with 3 and 3.5 as arguments. */ 20

21 Formal functions Formal functions are function arguments of other functions. This allows a generic use of functions. double dicho(double x, double y, double val, double (*f)(double)) { double z; /* hypothèse : f(x) * f(y) <= 0 */ if ((*f)(x) > 0) { z = x; x = y; y = z;} while (fabs(y - x) > val) { z = (x + y) / 2; if ((*f)(z) < 0) z = x; else y = z; } return z;} Returns ''z'' such that f(z) == val. 21

22 Quick preview It is possible to name continuous space in memory Arrays. But, as functions, the size of arrays is not always known during the compiling step. Static arrays. Dynamics arrays. 22