Outline. Introduction. Pointer variables. Pointer operators. Calling functions by reference. Using const with pointers. Examples.

Transcription

1 Outline Introduction. Pointer variables. Pointer operators. Calling functions by reference. Using const with pointers. Examples. 1

2 Introduction A pointer is a variable that contains a memory address Pointers Powerful, but difficult to master. Simulate call-by-reference. Allow the creation of dynamic data structures that shrink and grow in size during run time, such as stacks, link lists, etc. Close relationship with arrays and strings. 2

3 Pointer Variable Declarations and Initialization I Pointer variables Contain memory addresses as their values Normal variables contain a specific value (direct reference) Pointers contain the address of a variable that has a specific value (indirect reference) Indirection (the act of using a pointer) Referencing a pointer value (accessing the contents of the memory location indicated by the address found inside the pointer). Pointer declarations * indicates that a variable is a pointer int *myptr; // this statement means create a pointer that points to an integer data declares a pointer to an int, a pointer of type int * Multiple pointers require multiple asterisks int *myptr1, *myptr2; 3

4 Pointer Variable Declarations and Initialization II Can declare pointers to any data type Pointers initialization Initialized to 0, NULL, or an address 0 or NULL points to nothing Suppose that you defined x as float x = 3.5; You have two options to declare a pointer that points to x: 1- float *pt = &x; (now pt is a pointer to x) 2- float *pt; pt = &x; (now pt is a pointer to x) 4

5 Pointer Operators I & (address operator) Returns the address of its operand It is different from the reference operator used in declaring reference variables. Can be applied to variables only (cannot be applied to expressions or constants syntax error) Example int y = 5; int *yptr; yptr = &y; yptr points to y // yptr gets address of y yptr y 5 yptr y address of y is value of yptr 5

6 Pointer Operators II * (indirection/dereferencing operator) Returns the value of what its operand points to *yptr returns y (because yptr points to y). * can be used to assign a value to a location in memory *yptr = 7; // changes y to 7 Dereferenced pointer (operand of *) must be an lvalue (no constants) * and & are inverses Cancel each other out *&myvar == myvar and &*yptr == yptr 6

7 Example int f = 300; int *pt = &f; cout<<*pt<<endl; // print the value of f (300) cout<<&pt<<endl; // print the address in which pt pointer is stored at (0012FF6C) cout<<pt<<endl; // print the value of pt which is the address of f (0012FF70) 7

8 Pointer Operators III Dereferencing a variable that is not a pointer is a syntax error, e.g.: int y = 10; cout << *y; //syntax error Dereferencing a null-pointer is a fatal error (i.e. you program will abort abnormally). int *p; cout<<*p; // the program will run but after the run it will close abnormally The content of a pointer (which is a memory address) is expressed in hexadecimal when you print it on the screen. Some compilers may print it in decimal (machine dependent). You can change the address within the pointer during the program (i.e. you can change the variable to which the pointer is pointing). You must initialize the pointer with the address of a variable with the same data types as the pointer. e.g.: int *p; double y = 10; P = &y; //Syntax error 8

9 1 // Fig. 5.4: fig05_04.cpp 2 // Using the & and * operators 3 #include <iostream> 4 5 using std::cout; 6 using std::endl; 7 8 int main() 9 { 10 int a; // a is an integer 11 int *aptr; // aptr is a pointer to an integer a = 7; 14 aptr = &a; // aptr set to address of a cout << "The address of a is " << &a 17 << "\nthe value of aptr is " << aptr; cout << "\n\nthe value of a is " << a 20 << "\nthe value of *aptr is " << *aptr; cout << "\n\nshowing that * and & are inverses of " 23 << "each other.\n&*aptr = " << &*aptr 24 << "\n*&aptr = " << *&aptr << endl; 25 return 0; 26 } The address of a is 006AFDF4 The value of aptr is 006AFDF4 The value of a is 7 The value of *aptr is 7 Showing that * and & are inverses of each other. &*aptr = 006AFDF4 *&aptr = 006AFDF4 The address of a is the value of aptr. The * operator returns an alias to what its operand points to. aptr points to a, so *aptr returns a. Notice how * and & are inverses The Hashemite University 9

10 Using the const Qualifier with Pointers I const qualifier: Variable cannot be changed. const used when function does not need to change a variable. Attempting to change a const variable is a syntax error. const pointers: Point to same memory location during the whole program, i.e. the pointer cannot be modified to point to other data. Must be initialized when declared int *const myptr = &x; Pointer points to const data: Means that the data cannot be modified indirectly (i.e. through the pointer) by dereferencing the pointer. 10

11 Using the const Qualifier with Pointers II Types of const pointers: Non-constant pointer to a non-constant data e.g.: int *myptr = &x; Constant pointer to a non-constant data: default for array names e.g.: int *const myptr = &x; Non-constant pointer to a constant data e.g.: const int *myptr = &x; Constant pointer to a constant data e.g.: const int *const myptr = &x; 11

12 1 // Fig. 5.13: fig05_13.cpp 2 // Attempting to modify a constant pointer to 3 // non-constant data 4 #include <iostream> 5 6 int main() 7 { 8 int x, y; 9 10 int * const ptr = &x; // ptr is a constant pointer to an 11 // integer. An integer can be modified 12 // through ptr, but ptr always points 13 // to the same memory location. 14 *ptr = 7; 15 ptr = &y; return 0; 18 } Changing *ptr is allowed - x is not a constant. Changing ptr is an error - ptr is a constant pointer. Error E2024 Fig05_13.cpp 15: Cannot modify a const object in function main() 12