Pointers

What Is Pointer i ’y’ c 0021 0022 cp i ’y’ c 0021 0022 cp every variable has memory address char c=’y’; int i=2; address of variable i is 0022 address can used to refer to this variable address can be stored in a variable of special type called pointer (variable) C++ provides an abstraction of pointer pointer is used only to refer to the variable it points to - we usually don’t think of pointers as holding integer (address) just a reference to a variable pointer: a mechanism to uniformly manipulate multiple memory locations in sequence name memory address i ’y’ c 2 0021 0022 cp name memory address i ’y’ c 2 0021 0022 cp

Pointer Declaration pointer variable is declared as follows: typeOfVariablePointedTo *pointerName; example: double *p; int *ip; pointer declarations can be intermixed with ordinary variable declarations: char *cp, c1=’y’, c2=’n’; int i, *ip; star can move to type without changing semantics: int *i, j; is the same as int* i, j; pointer to a pointer is legal and sometimes used: char **cpp;

Reference and Dereference & reference or address of operator: returns the address of a variable, used to assign value to pointer cp = &c1; // until reassigned cp ”points to” c1 * dereference or indirection operator: access the location the pointer points to, two forms for reading: cout << *cp << endl; for writing: *cp = ’G’; note that star at pointer declaration is not a dereference operator – it just signifies that the variable is a pointer.

Pointer Usage pointer can be initialized char *cp2=&c2; int *ip; pointer can point to multiple variables (in sequence) and multiple pointers can point to the same variable what does this code fragment do? int *ip1, *ip2, one=1, two=2; ip1=&one; ip2=ip1; *ip1 = *ip1 + 1; ip1=&two; *ip1 -= 1; cout << *ip2 << ” ” << *ip1;

Constants and Pointers constant pointer: cannot change where pointer points to (can modify value in the location) char c = 'c'; const char d = 'd'; char *const ptr1 = &c; ptr1 = &d; // illegal pointer to a constant: cannot change what pointer points to (can make pointer point elsewhere) const char *ptr2 = &d; *ptr2 = 'e'; // illegal: cannot change d // through dereferencing ptr2 this also declares a pointer to a constant char const *ptr2 = &d; to recognize type, read from right to left

Array Names and Constant Pointers array name is in fact a constant pointer example int *p; // this is a pointer int a[SIZE]; // this is an array // int *const a; plus memory allocation // is equivalent p = a; // now pointer references first // element of an array an array name can be used as name and as pointer: a[3]=22; // as array name: applying indexing p = a; // as pointer a pointer can also be used similarly p[4]=44; // as name since array name is a constant pointer – its modification is not legal a=p; // ERROR!

Pointer Arithmetic array elements are guaranteed to be in continuous memory locations adding one to pointer advances it one memory location of its specified type int a[5], *p = a; p = p + 1; // p points to second element of array gives alternative way to manipulate arrays allowed pointer operations: add/subtract integer, compound assignment, increment, decrement, subtract two pointers of the same type (what’s the purpose of that?) ++p; // moves p one position to the right – points to // third element of array p -=2; // moves p two positions to the left cout << p – a; // prints how many elements between p and a other arithmetic operations, like pointer division or multiplication, are not allowed regular and pointer arithmetic operations can be intermixed *(++p) = 22; // what does this do? caution use only on continuous memory locations terse but obscure indexing may be clearer to understand error prone

Null Pointer/Loose Pointer Problem a pointer that is not initialized holds arbitrary value assigning a value to the location uninitialized pointer points to can lead to unpredictable results: loose (dangling) pointer problem int *ptr; *ptr = 5; // ERROR - loose pointer! what do you think the result of this assignment is? nullptr constant guaranteed to be different from any address in memory convenient for pointer initialization int *ptr = nullptr; assigning nullptr to pointer does not eliminate loose pointer, useful to check if pointer is initialized int *ptr2 = nullptr, i=5; *ptr2 = 5; // ERROR - still loose if (ptr2 == nullptr) // is it initialized? ptr2=&i; cout << *ptr2;

Pointers to Objects pointers can point to objects: myclass{ public: void setd(int i){d=i;}; int getd() const {return d;}; private: int d; }; myclass ob1, *obp=&ob1; members can be accessed using pointers: (*obp).setd(5); parentheses around (*obp) are needed because dot-operator has higher precedence than dereferencing a shorthand -> is used for accessing members of the object the pointer points to: cout << obp->getd();