Pointer Variables A pointer is a variable that

Pointer Variables A pointer is a variable that contains a memory address The address is commonly the location of another variable in memory This pointer “points” to the other variable in memory A pointer is declared using the general statement: type *name; e. g. int *i 1;

Important Uses of Pointers Allows functions to modify their arguments Supports dynamic memory allocation functions Improves the efficiency of certain routines Allows communication to other functions, programs, and hardware using shared memory and memory transfers Pointers are one of the most powerful features of C/C++ but are also the most dangerous

Pointer Operators &b return the memory address of variable b *p return the value of the variable at address p * is the complement of & so that *(&b)=b These operators have a higher precedence than other arithmetic operators except urinary minus which is equal int b = 7777, *p; p = &b; cout << *p; 7777

A Variable Pointing to Another Variable Memory address Variable in memory 1000 1003 p 1001 1002 i 1 1003 1004 7777 *p

Pointer Expressions p=q pointer assignment p++, p-- increment and decrement p=p+i addition of an integer i p=p-i subtraction of an integer i p == q test for equality p < q , p > q pointer comparison

char *ch = 3000; int *i = 3000; expression Memory (bytes) expression ch 3000 i ch + 1 3001 ch + 2 3002 ch + 3 3003 ch + 4 3004 ch + 5 3005 i+1

Pointers and Arrays A 1 D array is equivalent to a pointer to the first element There are two ways of accessing arrays: pointer arithmetic and array indexing, s 1[i]=*(s 1+i) Indexing can also be used on pointer variables char s 1[6] = “peach”, *p 1; p 1 = s 1; cout << s 1[3] << *(p 1+3) << p 1[3] << *(s 1+3); cccc

Passing Pointers and Arrays to Functions 1 D arrays and pointers are interchangeable when passing arguments to functions Since the memory location is passed to the function it will modify the contents of the array: call by reference No copies of the array are made when passed to the function Be sure to know the boundaries of the array to avoid invalid memory access

Modifying Function Arguments Pointers allow C functions to modify their arguments call by value int i = 0; fun 1(i); cout << i; 0 7777 call by reference int i = 0; fun 2(&i); cout << i; void fun 1(int i) { i = 7777; } void fun 2(int *i) { *i = 7777; }

Array Swapping int ar[2]={1, 2}, br[2]={3, 4}; int *a=ar, *b=br, *c; c = a; a = b; b = c; cout << a[0] << a[1] << “n”; cout << b[0] << b[1]; 34 12 This is more efficient than swapping each element Make sure you swap any dimension information too

Initializing Pointers Always initialize your pointers to valid memory locations A pointer initialized incorrectly is called a wild pointer Reading data from a wild pointer will return garbage Writing data to a wild pointer could overwrite program, data or operating system memory, e. g. int x, *p; x = 10; *p = x;

Common Problems With Pointers int x, *p; x = 10; p = x; cout << *p; improper usage char a[10], b[10]; char *p 1, *p 2; p 1 = a; p 2 = b; if (p 1 < p 2) … two arrays will not be stored in any particular order

Dynamic Memory Allocation static arrays allocate memory at the beginning of program execution char s 1[10], *p 1; p 1 = s 1; dynamic memory is allocated during program execution #include <stdlib. h> #include <malloc. h> char *p 1; p 1 = (char *)malloc(10*sizeof(char));

Dynamic Arrays Dynamic arrays are useful because the size of the array can be determined at run-time The size of the array can be made just small enough for the application The memory allocated can also be freed for other functions to use when it is no longer needed It must be freed before the program is finished using the function free(p 1)

New and Delete Operators C++ provides operators for dynamic memory allocation p = new type [size]; // new operator for allocation delete p; // delete operator freeing memory int *p 1; char *p 2; p 1 = new int; p 2 = new char [5]; *p 1 = 8; strcpy(p 2, ”ball”); cout << *p 1 << p 2; delete p 1; delete p 2; 8 ball

Comparison with C Allocation Routines New and delete have the following advantages over malloc and free: Automatically computes the size needed in bytes Automatically returns a pointer of a specified type Provides support for C++ features related to operator overloading, initialization, constructors, and destructors Note that both malloc and new can take longer to run than static memory allocation for large blocks of memory

Arrays of Pointers Arrays of pointers can be declared like any other type char *pa[2]; char p 1[]="hello", p 2[]="goodbye"; pa[0] = p 1; pa[1] = p 2; cout << "n" << pa[0] << "t" << pa[1]; cout << "n" << *(pa[0]+1) << "t" << *(pa[1]+1); cout << "n" << pa[0][1] << "t" << pa[1][1]; This is useful for developing multidimensional arrays

memory address 900 1004 1008 1009 100 A 100 B 100 C 100 D 100 E 100 F variable 1000 1008 100 E ‘h’ ‘e’ ‘l’ ‘o’ ‘’ ‘g’ ‘o’ pa pa[0] pa[1]

Pointers to Pointers Since pointers are stored in memory we can declare pointers to them as well char **pp; char *p, s[]="MJ"; p = s; // point to the string pp = &p; // get the pointer to p cout << "n" << p << "t" << *pp; cout << "n" << *(p+1) << "t" << *(*pp+1); A pointer to a pointer is the same as an array of pointers

p, s memory address 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 variable 1004 pp 1008 *pp ‘M’ ‘J’ **pp

pp pp[0] pp[1] memory address 900 1004 1008 1009 100 A 100 B 100 C 100 D 100 E 100 F variable 1000 1008 100 E ‘h’ ‘e’ ‘l’ ‘o’ ‘’ ‘g’ ‘o’ pa pa[0] pa[1]

Function Pointers Functions also have memory locations so we can define function pointers to them as follows double (*pf)(double x); // declare a function pointer pf = &f 1; // initialize pointer cout << "nf 1 = " << (*pf)(3); 9 double f 1(double x) { return (x*x); } This is very useful for passing functions to other functions

Why Pointers ? Allows functions to modify their arguments Supports dynamic memory allocation functions Improves the efficiency of certain routines (swapping, …) Allows communication to other functions, programs, and hardware using shared memory and memory transfers Useful for passing functions to other functions Important for developing multidimensional dynamic arrays

Review A 1 D array is the same as a pointer to the first element double s[2] = { 1. 0, 2. 0 }, *p; p = s; p[1] == s[1] == *(p+1) == *(s+1) == 2 We can dynamically allocate a 1 D array using new double *p; int n = 10; p = new double [n]; p[1] = 1. 0; delete p; We can also have a 1 D array of pointers which is the same as a pointer to a pointer double *pa[10], **pp; pp = pa;

Questions 1. Initialize a 1 D dynamic array of doubles from a file. Use new / delete (or malloc / free if CC is defined). 2. example file: 1. 1 3. 2. 2 2. Load an array of vectors (3 d) from a file and store them in dynamic memory using an array of pointers (hint: each element will point to a different vector). 3. 4. example file: 1. 0 2. 0 3. 0 1. 1 2. 1 3. 1

More on Static Multidimensional Arrays 2 D static arrays are stored in a row by row format int a[2][3] = {1, 2, 3, 4, 5, 6}; a= int *r 0, *r 1, i; r 0 = a[0]; r 1 = a[1]; for(i=0; i<6; i++) cout << r 0[i] << “ ”; 123456 for(i=0; i<3; i++) cout << r 1[i] << “ ”; 456 1 4 2 5 3 6

Limitations of Static Multidimensional Arrays They cannot be passed to general functions since arrays of different sizes cannot be used interchangeably int a[4][4]; a[0][0] = 1; f 1(a); can’t convert int[4][4] to int[][3] int fun 1(int a[3][3]) { return a[0][0]; } They also cannot be converted to a pointer to pointer Only use static multidimensional arrays for simple applications where the size is always fixed

Multidimensional Dynamic Arrays One way to construct a 2 D dynamic array: First allocate a 1 D dynamic array of pointers This will have a pointer to pointer type Then initialize each array element to a 1 D dynamic array that stores each row done ! Dynamic arrays of any size can be passed to a function since they all have pointer to pointer type

Row Swapping Rows of a dynamic array can be efficiently swapped by swapping the pointers to the rows int *pa[2], **m, r 0[] = {1, 2}, r 1[] = {3, 4}, *d; m = pa; m[0] = r 0; m[1] = r 1; cout << m[0][0] << m[0][1] << “n” << m[1][0] << m[1][1]; d = m[0]; m[0] = m[1]; m[1] = d; cout << “nn”; cout << m[0][0] << m[0][1] << “n” << m[1][0] << m[1][1];

Pointers to Objects class string_class { public: char str[100]; void strcpy 2(char *s); }; void string_class: : strcpy 2(char *s) { strcpy(str, s); } string_class s 1, *sp; s 1. strcpy 2(“ya”); sp = &s 1; cout << s 1. str << (*sp). str << sp->str; yayaya

Arrays of Objects string_class s 1[3], *sp; s 1[0]. strcpy 2(“one”); s 1[1]. strcpy 2(“two”); s 1[2]. strcpy 2(“three”); sp = s 1; cout << sp->str << “n“; sp++; one cout << sp->str << “n“; sp++; two cout << sp->str << “n”; three cout << sp[0]. str; three

Dynamically Allocated Objects string_class *sp 1, *sp 2; sp 1 = new string_class(“apple”); // initialize object to “apple” sp 2 = new string_class [3]; // can’t initialize dynamic arrays sp 2[0]. strcpy 2(“peach”); cout << sp 1 ->str << “ “ << sp 2[0]. str << “n”; delete sp 1; delete [3] sp 2; // need to put [size] first for dyn object arrays string_class: : string_class(char *s) { strcpy(str, s); cout << “constructn”; } // for sp 1 string_class: : string_class() { cout << “c 0n”; } // for sp 2

Constructor Functions A constructor function can be defined that automatically gets called when an object is created, e. g. class string_class { public: string_class(char *s) { cout << “constructn”; } }; Constructor functions are used to initialize an object (setting variables, allocating dynamic memory, etc. ) You should also define a constructor that takes no parameters if you intend to declare an array of objects

Destructor Functions A destructor function can also be defined that automatically gets called when an object is destroyed class string_class { public: ~string_class() { cout << “destructn”; } }; Destructors are used to clean up when an object is destroyed (close files, free dynamic memory, etc. ) Destructors do not take any parameters

Constructor and Destructor Functions It is important to recognize when objects are created (constructor) and destroyed (destructor) in a program Special care should be taken when dynamic memory is allocated in the constructor and freed in the destructor Repeated new (malloc) and delete (free) statements must be avoided since they can destabilize the program p 1 = new double [10]; // invalid delete p 1; // invalid

Object Creation and Destruction Global objects are created when the program is initially executed and destroyed when the program ends Local objects are created when the program enters the function and are destroyed when the function returns Dynamic objects are created at the new statement and destroyed at the delete statement When a static or dynamic array of objects is declared an object is created / destroyed for each element in the array Same rules apply for simple variable types (double, etc. )

Object Creation and Destruction Function parameters that are call by value are copied when entering the function, but a constructor is not called Call by value parameters are destroyed when the function returns the destructor will be called too many times Call by reference parameters are not copied or destroyed by a function Use call by reference for objects that have destructors or dynamic memory. Note that the object can be modified Returning an object will make a copy (no constructor) but the destructor is also called for the returned object

References A reference is an implicit pointer (C++) that basically acts like a second name for a variable References have three main uses: 1. Call by reference function parameters 2. To create an alternative name for a variable 3. Returning a reference from a function The usage of references is much more restricted than a pointer. Don’t bother trying to use them for anything else

Topic Review Pointers and 1 D arrays Dynamic memory Arrays of pointers Pointer to pointers Function pointers Multidimensional Dynamic arrays Pointers to objects and object arrays Constructor and Destructor functions