1.9.4.1. Pointer Syntax¶

When declaring a pointer in C++ that will “point” to the memory address of some data type, you will use the same rules of declaring variables and data types. The key difference is that there must be an asterisk (*) between the data type and the identifier.

variableType *identifier; // syntax to declare a C++ pointer
int *ptrx; // example of a C++ pointer to an integer

White space in C++ generally does not matter, so the following pointer declarations are identical:

SOMETYPE *variablename; // preferable
SOMETYPE * variablename;
SOMETYPE* variablename;

However, the first declaration is preferable because it is clearer to the programmer that the variable is in fact a pointer because the asterisk is closer to the variable name.

1.9.4.2. The address-of operator, &¶

Now that we know how to declare pointers, how do we give them the address of where the value is going to be stored? One way to do this is to have a pointer refer to another variable by using the address-of operator, which is denoted by the ampersand symbol, &. The address-of operator & does exactly what it indicates, namely it returns the address.

The syntax is shown below, where varName stores the value, and varPntr stores the address of where varName is located:

variableType varName;  // a variable to hold the value
variableType *varPntr = &varName;  // a variable pointing to the address of varName

Keep in mind that when declaring a C++ pointer, the pointer needs to reference the same type as the variable or constant to which it points.

Expanding on the example above where varName has the value of 100.

//variable declaration for a single integer value
int varName = 100;
int *varPntr;
varPntr = &varName;

The results of running this C++ code will look like the diagram below.

Figure 5: FIXME2

1.9.4.3. Accessing Values from Pointers¶

So, once you have a C++ pointer, how do you access the values associated with that location? You use the asterisk before the pointer variable, which goes to that address, effectively dereferencing the pointer, meaning that it will find the location of the value stored where the pointer was pointing.

In other words, varName and *varPntr (note the asterisk in front!) reference the same value in the code above.

Let’s extend the example above to output the value of a variable and its address in memory:

#include <iostream> using namespace std; int main( ) { int varName = 100; int *varPntr = &varName; cout << "varName value: " << varName << endl; cout << "varPntr location: " << varPntr << endl; cout << "varPntr points to varName: " << endl; cout << "dereference varPntr: " << *varPntr << "\n\n"; varName = 50; cout << "varName changed: " << varName << endl; cout << "varPntr still points to varName: " << endl; cout << "dereference varPntr: " << *varPntr << "\n\n"; *varPntr = 2000; cout << "Changed *varPntr, ie varName to: " << endl; cout << "dereference varPntr: " << *varPntr << "\n\n"; return 0; }

Compiling and running the above code will have the program output the value in varName, what is in varPntr (the memory address of varName), and what value is located at that memory location.

The second output sentence is the address of varName, which would most likely be different if you run the program on your machine.

WARNING: What happens if you forget the asterisk when assigning a value to a pointer and had the following instructions instead?

#include <iostream> using namespace std; int main( ) { int varName = 100; int varPntr = varName; // Note no asterisk, // varPntr now refers to memory position 100, // whatever happens to be there! // You might get an error or you might not! cout << "varName value: " << varName << endl; cout << "varPntr location: " << varPntr << endl; cout << "varPntr points to varName: " << endl; cout << "dereference varPntr: " << *varPntr << "\n\n"; return 0; }

This is BAD, BAD, BAD!

Figure 6: FIXME3

If your compiler does not catch that error (the one for this class may), the first cout instruction outputs:

After changing *varPntr, varName now has: 50

which is expected because you changed where varPntr is pointing to and NOT the contents of where it is pointing.

The second cout instruction is a disaster because

1. You don’t know what is stored in location 100 in memory, and

(2) that location is outside of your segment (area in memory reserved for your program), so the operating system will jump in with a message about a “segmentation fault”. Although such an error message looks bad, a “seg fault” is in fact, a helpful error because unlike the elusive logical errors, the reason is fairly localized.

1.9.4.4. The NULL pointer¶

The NULL pointer in C++ points to nothing and is often denoted by the keyword NULL (all caps) or by 0. The NULL pointer is often used in conditions and/or in logical operations.

The following example demonstrates how the NULL pointer works. The variable ptrx initially has the address of x when it is declared. On the first iteration of the loop, it is assigned the value of NULL (i.e. 0) thereby ending the loop:

#include <iostream> using namespace std; int main( ) { int x = 12345; int *ptrx = &x; while (ptrx) { cout << "Pointer ptrx points to " << &ptrx << endl; ptrx = NULL; } cout << "Pointer ptrx points to nothing!\n"; }

Helpful Tip: The NULL pointer becomes very useful when you must test the state of a pointer, such as whether the assignment to an address is valid or not.