1. Chapter 10: Pointers Starting Out with C++ Early Objects Ninth Edition
by Tony Gaddis, Judy Walters, and Godfrey Muganda

2. Topics
10.1 Pointers and the Address Operator 10.2 Pointer Variables 10.3 The Relationship Between Arrays and Pointers 10.4 Pointer Arithmetic 10.5 Initializing Pointers 10.6 Comparing Pointers 10.7 Pointers as Function Parameters

3. Topics (continued)
10.8 Pointers to Constants and Constant Pointers 10.9 Dynamic Memory Allocation Returning Pointers from Functions Pointers to Class Objects and Structures Selecting Members of Objects Smart Pointers

4. 10.1 Pointers and the Address Operator
Each variable in a program is stored at a unique location in memory that has an address
Use the address operator & to get the address of a variable:
int num = -23;
cout << &num; // prints address
// in hexadecimal
The address of a memory location is a pointer
See pr10-01.cpp

5. 10.2 Pointer Variables
Pointer variable (pointer): a variable that holds an address
Pointers provide an alternate way to access memory locations

6. Pointer Variables Definition: int *intptr; Read as:
“intptr can hold the address of an int” or “the variable that intptr points to has type int”
The spacing in the definition does not matter:
int * intptr;
int* intptr;
* is called the indirection operator

7. Pointer Variables cout << intptr; // prints 0x4a00
Definition and assignment:
int num = 25;
int *intptr;
intptr = &num;
Memory layout:
You can access num using intptr and indirection operator *:
cout << intptr; // prints 0x4a00
cout << *intptr; // prints 25
*intptr = 20; // puts 20 in num
num
intptr 25
0x4a00
address of num: 0x4a00
See pr10-02.cpp, pr10-03.cpp and pr10-04.cpp

8. 10.3 The Relationship Between Arrays and Pointers
An array name is the starting address of the array
int vals[] = {4, 7, 11};
cout << vals; // displays 0x4a00
cout << vals[0]; // displays 4 4 7 11
starting address of vals: 0x4a00

9. The Relationship Between Arrays and Pointers
An array name can be used as a pointer constant
int vals[] = {4, 7, 11};
cout << *vals; // displays 4
A pointer can be used as an array name
int *valptr = vals;
cout << valptr[1]; // displays 7
See pr10-05.cpp, pr10-06.cpp, pr10-07.cpp, and pr10-08.cpp

10. Pointers in Expressions
Given:
int vals[]={4,7,11};
int *valptr = vals;
What is valptr + 1?
It means (address in valptr) + (1 * size of an int)
cout << *(valptr+1); // displays 7
cout << *(valptr+2); // displays 11
Must use ( ) in expression

11. Array Access Array elements can be accessed in many ways
Array access method
Example
array name and [ ]
vals[2] = 17;
pointer to array and [ ]
valptr[2] = 17;
array name and subscript arithmetic
*(vals+2) = 17;
pointer to array and subscript arithmetic
*(valptr+2) = 17;

12. Array Access Array notation vals[i]
is equivalent to the pointer notation
*(vals + i)
Remember that no bounds checking is performed on array access

13. 10.4 Pointer Arithmetic
Some arithmetic operators can be used with pointers:
Increment and decrement operators ++, --
Integers can be added to or subtracted from pointers using the operators +, -, +=, and -=
One pointer can be subtracted from another by using the subtraction operator -

14. Pointer Arithmetic Assume the variable definitions
int vals[]={4,7,11};
int *valptr = vals;
Examples of use of ++ and --
valptr++; // points at 7
valptr--; // now points at 4
See pr10-09.cpp

15. More on Pointer Arithmetic
Assume the variable definitions:
int vals[]={4,7,11};
int *valptr = vals;
Example of the use of + to add an int to a pointer:
cout << *(valptr + 2)
This statement will print 11

16. More on Pointer Arithmetic
Assume the variable definitions:
int vals[]={4,7,11};
int *valptr = vals;
Example of use of +=:
valptr = vals; // points at 4
valptr += 2; // points at 11

17. More on Pointer Arithmetic
Assume the variable definitions
int vals[] = {4,7,11};
int *valptr = vals;
Example of pointer subtraction
valptr += 2;
cout << valptr - val;
This statement prints 2: the number of
ints between valptr and val

18. 10.5 Initializing Pointers
You can initialize to NULL or 0 (zero)
int *ptr = NULL;
You can initialize to addresses of other variables
int num, *numPtr = &num;
int val[ISIZE], *valptr = val;
The initial value must have the correct type
float cost;
int *ptr = &cost; // won't work

19. Initializing Values in C++ 11
In C++ 11, putting empty { } after a variable definition indicates that the variable should be initialized to its default value
C++ 11 also has the the key word nullptr to indicate that a pointer variable does not contain a valid memory location
You can use
int *ptr = nullptr; or
int *ptr{ };

20. 10.6 Comparing Pointers
Relational operators can be used to compare the addresses in pointers
Comparing addresses in pointers is not the same as comparing contents pointed at by pointers:
if (ptr1 == ptr2) // compares
// addresses
if (*ptr1 == *ptr2) // compares
// contents
See pr10-10.cpp

21. 10.7 Pointers as Function Parameters
A pointer can be a parameter
It works like a reference parameter to allow changes to argument from within a function
A pointer parameter must be explicitly dereferenced to access the contents at that address

22. Pointers as Function Parameters
Requires:
1) asterisk * on parameter in prototype and
header
void getNum(int *ptr);
2) asterisk * in body to dereference the pointer
cin >> *ptr;
3) address as argument to the function in the call
getNum(&num);
See pr10-11.cpp

23. Pointers as Function Parameters
void swap(int *x, int *y) { int temp; temp = *x; *x = *y; *y = temp; } int num1 = 2, num2 = -3; swap(&num1, &num2); //call
See pr10-12.cpp

24. Passing an Array Via a Pointer Parameter
A pointer parameter receives an address when a function is called
The address could be for a single variable, or it could be the address of the first element of an array.
You can use either subscript notation or pointer arithmetic to access the elements of the array.

25. 10.8 Ponters to Constants and Constant Pointers
A pointer to a constant: you cannot change the value that is pointed at
A constant pointer: the address in the pointer cannot be changed after the pointer is initialized

26. Pointers to Constants
Must use the const keyword in the pointer definition:
const double taxRates[] =
{0.65, 0.8, 0.75};
const double *ratePtr;
Use the const keyword for pointer parameters in function headers to protect data from modification in the function, as well as to pass addresses of const arguments

27. Pointer to Constant – What does the Definition Mean?
See pr10-13.cpp
Read as: “rates is a pointer to a constant that is a double.”

28. Constant Pointers
A constant pointer is a pointer whose data (the address in the pointer) cannot change
It is defined with the const keyword adjacent to the variable name:
int classSize = 24;
int * const classPtr = &classSize;
It must be initialized when defined
No initialization needed if used as a function parameter
Initialized by the argument when function is called
Function can receive different arguments on different calls
While the address in the pointer cannot change, the data at that address may be changed

29. Constant Pointer – What does the Definition Mean?
Read as: “ptr is a constant pointer to an int.”

30. Constant Pointer to Constant
You can combine pointers to constants and constant pointers:
int size = 10;
const int * const ptr = &size;
What does it mean?

31. 10.9 Dynamic Memory Allocation
You can allocate storage for a variable while a program is running
Use the new operator to allocate memory
double *dptr;
dptr = new double;
new returns address of a memory location
The data type of the variable is indicated after new

32. Dynamic Memory Allocation
You can also use new to allocate an array
arrayPtr = new double[25];
The program may terminate if there is not sufficient memory
You can then use [ ] or pointer arithmetic to access array

33. Dynamic Memory Example
int *count, *arrayptr; count = new int; cout <<"How many students? "; cin >> *count; arrayptr = new int[*count]; for (int i=0; i<*count; i++) { cout << "Enter score " << i << ": "; cin >> arrayptr[i]; }

34. Releasing Dynamic Memory
Use delete to free dynamic memory
delete count;
Use delete [] to free dynamic array memory
delete [] arrayptr;
Only use delete with dynamic memory!
See pr10-14.cpp

35. Dangling Pointers and Memory Leaks
A pointer is dangling if it contains the address of memory that has been freed by a call to delete.
Solution: set such pointers to NULL (or nullptr in C++ 11) as soon as the memory is freed.
A memory leak occurs if no-longer-needed dynamic memory is not freed. The memory is unavailable for reuse within the program.
Solution: free up dynamic memory after use

36. 10.10 Returning Pointers from Functions
A pointer can be the return type of function
int* newNum();
The function must not return a pointer to a local variable in the function
The function should only return a pointer
to data that was passed to the function as an argument
to dynamically allocated memory
See pr10-15.cpp

37. More on Memory Leaks General guidelines to avoid memory leaks:
If a function allocates memory via new, it should, whenever possible, also deallocate the memory using delete
If a class needs dynamic memory, it should
allocate it using new in the constructor
deallocate it using delete in the destructor
See pr10-16.cpp

38. 10.11 Pointers to Class Objects and Structures
You can create pointers to objects and structure variables
struct Student {…};
class Square {…};
Student stu1;
Student *stuPtr = &stu1;
Square sq1[4];
Square *squarePtr = &sq1[0];
You need to use() when using * and . operators
(*stuPtr).studentID = 12204;

39. Structure Pointer Operator ‒>
Simpler notation than (*ptr).member
Use the form ptr->member
stuPtr->studentID = 12204;
squarePtr->setSide(14);
in place of the form (*ptr).member
(*stuPtr).studentID = 12204;
(*squarePtr).setSide(14);

40. Dynamic Memory with Objects
You can allocate dynamic structure variables and objects using pointers:
stuPtr = new Student;
You can pass values to the object’s constructor:
squarePtr = new Square(17);
delete causes destructor to be invoked:
delete squarePtr;
See pr10-17.cpp

41. Structure/Object Pointers as Function Parameters
Pointers to structures or objects can be passed as parameters to functions
Such pointers provide a pass-by-reference parameter mechanism
Pointers must be dereferenced in the function to access the member fields
See pr10-18.cpp

42. 10.12 Selecting Members of Objects
Situation: A structure/object contains a pointer as a member. There is also a pointer to the structure/ object.
Problem: How do we access the pointer member via the structure/object pointer?
struct GradeList
{ string courseNum;
int * grades; }
GradeList test1, *testPtr = &test1;

43. Selecting Members of Objects
Expression
Meaning
testPtr->grades
Access the grades pointer in test1. This is the same as (*testPtr).grades
*testPtr->grades
Access the value pointed at by testPtr->grades. This is the same as *(*testPtr).grades
*test1.grades
Access the value pointed at by test1.grades

44. 10.13 Smart Pointers Introduced in C++ 11
They can be used to solve the following problems in a large software project
dangling pointers – pointers whose memory is deleted while the pointer is still being used
memory leaks – allocated memory that is no longer needed but is not deleted
double-deletion – two different pointers de-allocating the same memory

45. Smart Pointers Smart pointers are objects that work like pointers.
Unlike regular (raw) pointers, smart pointers can automatically delete dynamic memory that is no longer being used.
There are three types of smart pointers:
unique pointers (unique_ptr)
shared pointers (shared_ptr)
weak pointers (weak_ptr)

46. Unique Pointers
A smart pointer owns (or manages) the object that it points to.
A unique pointer points to a dynamically allocated object that has a single owner.
Ownership can be transferred to another unique pointer.
Memory for the object is deallocated when the owning unique pointer goes out of scope, or if it takes ownership of a different object.

47. Unique Pointer Examples
Requires the <memory> header file
Create a unique pointer that points to an int:
unique_ptr<int> uptr(new int);
Assign the value 5 to it and print it:
*uptr = 5;
cout << *uptr;
Transfer ownership to unique pointer ptr2:
unique_ptr<int> uptr2;
uptr2 = move(uptr);

48. Unique Pointers and Ownership Transfers – the move() function
In a statement such as:
uptr2 = move(uptr);
Any object owned by uptr2 is deallocated
uptr2 takes ownership of the object previously owned by uptr
uptr becomes empty

49. The move() Function and Unique Pointers as Parameters
The move() function is required on the argument when passing a unique pointer by value.
The move() function is not required for pass by reference
A unique pointer can be returned from a function, as the compiler automatically uses move() in this case.

50. Manually Clearing a Unique Pointer
Unique pointers deallocate the memory for their objects when they go out of scope.
To manually deallocate memory, use
uptr = nullptr; or
uptr.reset();

51. Unique Pointers and Arrays
Use array notation when using an unique pointer to allocate memory for an array
unique_ptr<int[]>uptr3(new int[5]);
Doing so ensures that the proper deallocation (delete[] instead of delete) will be used.
See pr10-19.cpp

52. Shared Pointers
A smart pointer owns (or manages) the object that it points to.
A shared pointer points to a dynamically allocated object that may have multiple owners.
A control block manages the reference count of the number of shared owners and also possibly the raw pointer if one exists.

53. Creating Shared Pointers
Create a shared pointer to point to an existing dynamic object declared with a raw pointer:
int * rawPtr = new int;
shared_ptr<int> uptr4(rawPtr);
Create a second shared pointer initialized to the same object:
shared_ptr<int>uptr5 = uptr4;
rawPtr, uptr4, and uptr5 are all tracked in the control block.

54. How Many Control Blocks?
Be careful that all references to a dynamic object are tracked in the same control block
In the code below:
int * rawPtr = new int;
shared_ptr<int> uptr4(rawPtr);
shared_ptr<int> uptr5(rawPtr);
Two control blocks are created. This can cause a dangling pointer.

55. Memory Management Tip
Creating a shared pointer involves memory for the object and memory for the control block.
These memory allocations can be combined by using the make_shared function:
shared_ptr<int> uptr6 = make_shared<int>();
You can also pass parameters to a constructor using an overloaded version of make_shared.

56. Chapter 10: Pointers Starting Out with C++ Early Objects Ninth Edition
by Tony Gaddis, Judy Walters, and Godfrey Muganda