Beginning C++ Through Game Programming,

Second Edition by Michael Dawson

Chapter 7

Pointers: Tic-Tac-Toe 2.0

Objectives• Declare and initialize pointers• Dereference pointers• Use constants and pointers• Pass and return pointers• Work with pointers and arrays

Pointer Basics

• A pointer is a variable that can contain a memory address • Pointers give you the ability to work directly and efficiently with memory • Like iterators, they're often used to access the contents of other variables

Declaring Pointers int* pAPointer;

• Programmers often prefix pointer variable names with p• Declared to point to a specific type of value• pAPointer is a pointer to int; it can only point to an int value.

Pointer Declaration Pitfalls

int* pScore, score;• score is not a pointer! It’s a variable

of type int.

• Clearerint *pScore, score;

• Clearestint* pScore;int score;

Initializing Pointers

int* pScore = 0;

• Assigning 0 to means “point to nothing” • Called a null pointer• Can use NULL instead of 0

Assigning Addresses to Pointers

• Assign pointer pScore address of variable scorepScore = &score;

Dereferencing Pointers• Dereference a pointer to access the object to which it pointscout << *pScore;

• Sends cout value that pScore points to • Don’t dereference a null pointer• Don't forget to dereference a pointerpScore += 500;

• Adds 500 to the address stored in pScore, not to the value to which pScore originally pointed

Reassigning Pointers

• Unlike references, pointers can point to different objects pScore = &newScore;

• Following doesn't change pScore, only the value to which it points*pScore = newScore;

Using Pointers to Objectsstring str = "score";string* pStr = &str;

• Can call member functions of an object through a pointer, just as with iteratorscout << (*pStr).size();

• Just as with iterators, you can use the -> operator with pointers for a more readable way to access object memberscout << pStr->size();

Constant Pointer

int i = 100;int* const p = &i;

• Can only point to the object to which it was initialized to point• Can be used to change value it points to• Can only point to a non-constant value; can’t point to a constant.

Pointer to a Constant

const int* p;

• Can’t be used to change the value to which it points • Can point to different objects • Can point to a constant or non-constant value

Constant Pointer to a Constant

cont int I = 100;const int* const p = &I;

• Can only point to the value to which it was initialized to point• Can’t be used to change the value to which it points• Can be initialized to point to a constant or a non-constant value

Passing Pointers

• Can pass access to variables using pointers• Just as with references• References are the preferred way to pass arguments

Example: Passing Pointers• When you pass a pointer, you pass only the address of an object• Can be quite efficient, especially if you’re working with large objectsvoid Swap(int* const pX, int* const pY) • pX and pY are constant pointers and will each accept a memory address • Must pass addresses when passing to pointer parameters Swap(&myScore, &yourScore);

Returning Pointers• Can return pointer from a function• Preferred method is to return reference• Specify that you’re returning a pointer in function headerstring* func()

• Return an address in the function bodyreturn &myString;

Pitfalls of Return Pointers

• Don't return a pointer that points to an out-of-scope object • Never return a pointer to a local variable

string* badPointer(){ string local = "Won't exist."; string* pLocal = &local;

return pLocal;}

Assignments and Returned Pointers

• Assign the returned pointer to a pointer that points to an object of the same typestring* pStr = func();

• Efficient; assigning a pointer to a pointer, no string object is copied.string str = func();

• Copies the string object that the returned pointers point to• For large objects, could be an expensive operation

Pointers and Arrays

• An array name is really a constant pointer to the first element of the array • Elements of an array are stored in a contiguous block of memory• Can use the array name as a pointer for random access to elements • Pass arrays as pointers

Using Array Name as a Pointer

const int NUM_SCORES = 3;int highScores[NUM_SCORES] = {5000, 3500, 2700}; cout << *highScores << endl;cout << *(highScores + 1) << endl;cout << *(highScores + 2) << "\n\n";

Output is as follows:500035002700

Passing Array as a Pointervoid display(const int* const array,

const int NUM_ELEMENTS){ for (int i = 0; i < NUM_ELEMENTS; ++i) cout << array[i] << endl;}

• Accepts array and number of elements • Displays all elements

Summary

• A pointer is a variable that contains a memory address• Pointers act like iterators from the STL• To declare a pointer, list a type, followed by an asterisk, followed by a name • A pointer is declared to hold memory address of a specific type• Good practice to initialize a pointer when you declare it

Summary (cont.)• If you assign 0 to a pointer, the pointer is called a null pointer• To get the address of a variable, put the address of the operator (&) before the variable name• Unlike references, you can reassign pointers• Dereference a pointer to access the object it points to with *, the dereference operator• Use the -> operator with pointers for a more readable way to access object data members and member functions

Summary (cont.)

• A constant pointer can only point to the object it was initialized to point to • Can't use a pointer to a constant to change the value to which it points• A constant pointer to a constant can only point to the value it was initialized to point to, and it can’t be used to change that value • You can pass pointers for efficiency or to provide direct access to an object• A dangling pointer is a pointer to an invalid memory address • Dereferencing a dangling pointer can lead to disastrous results• You can return a pointer from a function, but be careful not to return a dangling pointer