Contents

4.1. Pointers ................................................................................................................. 1

4.1.1. Dynamic Memory ......................................................................................... 2
4.1.2. Pointer Arithmetic ......................................................................................... 4
4.1.3. Function Pointers .......................................................................................... 5
4.1.4. References ..................................................................................................... 7
4.1.5. Typedefs ........................................................................................................ 9

4.1. Pointers
A pointer is simply the address of a memory location and provides an indirect way of
accessing data in memory. A pointer variable is defined to ‘point to’ data of a specific
type. For example:

int *ptr1; // pointer to an int

char *ptr2; // pointer to a char
The value of a pointer variable is the address to which it points. For example, given the
definitions

int num;
we can write:
ptr1 = #

The symbol & is the address operator; it takes a variable as argument and returns the
memory address of that variable. The effect of the above assignment is that the address of
num is assigned to ptr1. Therefore, we say that ptr1 points to num. Figure 5.Error!
Bookmark not defined. illustrates this diagrammatically.

ptr1 num
Figure: A simple integer pointer.
Given that ptr1 points to num, the expression

*ptr1

dereferences ptr1 to get to what it points to, and is therefore equivalent to num. The
symbol * is the dereference operator; it takes a pointer as argument and returns the
contents of the location to which it points.

1
In general, the type of a pointer must match the type of the data it is set to point to. A
pointer of type void*, however, will match any type. This is useful for defining pointers
which may point to data of different types, or whose type is originally unknown. A
pointer may be cast (type converted) to another type. For example,

ptr2 = (char*) ptr1;

converts ptr1 to char pointer before assigning it to ptr2.

Regardless of its type, a pointer may be assigned the value 0 (called the null pointer). The
null pointer is used for initializing pointers, and for marking the end of pointer-based data
structures (e.g., linked lists). 

4.1.1. Dynamic Memory

In addition to the program stack (which is used for storing global variables and stack
frames for function calls), another memory area, called the heap, is provided. The heap is
used for dynamically allocating memory blocks during program execution. As a result, it
is also called dynamic memory. Similarly, the program stack is also called static
memory.

Two operators are used for allocating and deallocating memory blocks on the heap. The
new operator takes a type as argument and allocated a memory block for an object of that
type. It returns a pointer to the allocated block. For example,

int *ptr = new int;

char *str = new char[10];
allocate, respectively, a block for storing a single integer and a block large enough for
storing an array of 10 characters.

Memory allocated from the heap does not obey the same scope rules as normal
variables. For example, in

void Foo (void)

{
char *str = new char[10];
//...
}

when Foo returns, the local variable str is destroyed, but the memory block
pointed to by str is not. The latter remains allocated until explicitly released
by the programmer.

2
 The delete operator is used for releasing memory blocks allocated by new. It
takes a pointer as argument and releases the memory block to which it points. For
example:

delete ptr; // delete an object

delete [] str; // delete an array of objects

Note that when the block to be deleted is an array, an additional [] should be

included to indicate this.
Should delete be applied to a pointer which points to anything but a
dynamically-allocated object (e.g., a variable on the stack), a serious runtime
error may occur. It is harmless to apply delete to the 0 pointer.
Dynamic objects are useful for creating data which last beyond the
function call which creates them. Listing 5.1 illustrates this using a function
which takes a string parameter and returns a copy of the string.

Listing 5.1
1 #include <string.h>

2 char* CopyOf (const char *str)

3 {
4 char *copy = new char[strlen(str) + 1];

5 strcpy(copy, str);
6 return copy;
7 }

Annotation (analysis)
1 This is the standard string header file which declares a variety of functions
for manipulating strings.
4 The strlen function (declared in string.h) counts the characters in its
string argument up to (but excluding) the final null character. Because the
null character is not included in the count, we add 1 to the total and allocate
an array of characters of that size.
5 The strcpy function (declared in string.h) copies its second argument
to its first, character by character, including the final null character.

Because of the limited memory resources, there is always the possibility

that dynamic memory may be exhausted during program execution, especially
when many large blocks are allocated and none released. Should new be unable
to allocate a block of the requested size, it will return 0 instead. It is the
responsibility of the programmer to deal with such possibilities.


3
 4.1.2. Pointer Arithmetic
In C++ one can add an integer quantity to or subtract an integer quantity from
a pointer. This is frequently used by programmers and is called pointer
arithmetic. Pointer arithmetic is not the same as integer arithmetic, because the
outcome depends on the size of the object pointed to. For example, suppose
that an int is represented by 4 bytes. Now, given
char *str = "HELLO";
int nums[] = {10, 20, 30, 40};
int *ptr = &nums[0]; // pointer to first element

str++ advances str by one char (i.e., one byte) so that it points to the second
character of "HELLO", whereas ptr++ advances ptr by one int (i.e., four bytes)
so that it points to the second element of nums. Figure 5.1 illustrates this
diagrammatically.

Figure 5.1 Pointer arithmetic.

H E L L O \0 10 20 30 40

str ptr

str++ ptr++

It follows, therefore, that the elements of "HELLO" can be referred to as

*str, *(str + 1), *(str + 2), etc. Similarly, the elements of nums can be
referred to as *ptr, *(ptr + 1), *(ptr + 2), and *(ptr + 3).
Another form of pointer arithmetic allowed in C++ involves subtracting
two pointers of the same type. For example:
int *ptr1 = &nums[1];
int *ptr2 = &nums[3];
int n = ptr2 - ptr1; // n becomes 2

Pointer arithmetic is very handy when processing the elements of an array.

Listing 5.2 shows as an example a string copying function similar to strcpy.

Listing 5.2
1 void CopyString (char *dest, char *src)
2 {
3 while (*dest++ = *src++)
4 ;
5 }

Annotation
3 The condition of this loop assigns the contents of src to the contents of
dest and then increments both pointers. This condition becomes 0 when
the final null character of src is copied to dest.

4
 In turns out that an array variable (such as nums) is itself the address of the
first element of the array it represents. Hence the elements of nums can also be
referred to using pointer arithmetic on nums, that is, nums[i] is equivalent to
*(nums + i). The difference between nums and ptr is that nums is a constant,
so it cannot be made to point to anything else, whereas ptr is a variable and
can be made to point to any other integer.
Listing 5.3 shows how the HighestTemp function (shown earlier in Listing
5.Error! Bookmark not defined.) can be improved using pointer arithmetic.
Listing 5.3
1 int HighestTemp (const int *temp, const int rows, const int columns)
2 {
3 int highest = 0;

4 for (register i = 0; i < rows; ++i)

5 for (register j = 0; j < columns; ++j)
6 if (*(temp + i * columns + j) > highest)
7 highest = *(temp + i * columns + j);
8 return highest;
9 }

Annotation
1 Instead of passing an array to the function, we pass an int pointer and two
additional parameters which specify the dimensions of the array. In this
way, the function is not restricted to a specific array size.
6 The expression *(temp + i * columns + j) is equivalent to temp[i][j]
in the previous version of this function.

HighestTemp can be simplified even further by treating temp as a one-

dimensional array of row * column integers. This is shown in Listing 5.4.

Listing 5.4
1 int HighestTemp (const int *temp, const int rows, const int columns)
2 {
3 int highest = 0;

4 for (register i = 0; i < rows * columns; ++i)

5 if (*(temp + i) > highest)
6 highest = *(temp + i);
7 return highest;
8 }


4.1.3. Function Pointers

It is possible to take the address of a function and store it in a function pointer.
The pointer can then be used to indirectly call the function. For example,
int (*Compare)(const char*, const char*);

5
 defines a function pointer named Compare which can hold the address of any
function that takes two constant character pointers as arguments and returns an
integer. The string comparison library function strcmp, for example, is such.
Therefore:
Compare = &strcmp; // Compare points to strcmp function

The & operator is not necessary and can be omitted:

Compare = strcmp; // Compare points to strcmp function

Alternatively, the pointer can be defined and initialized at once:

int (*Compare)(const char*, const char*) = strcmp;

When a function address is assigned to a function pointer, the two types

must match. The above definition is valid because strcmp has a matching
function prototype:
int strcmp(const char*, const char*);

Given the above definition of Compare, strcmp can be either called

directly, or indirectly via Compare. The following three calls are equivalent:
strcmp("Tom", "Tim"); // direct call
(*Compare)("Tom", "Tim"); // indirect call
Compare("Tom", "Tim"); // indirect call (abbreviated)

A common use of a function pointer is to pass it as an argument to another

function; typically because the latter requires different versions of the former
in different circumstances. A good example is a binary search function for
searching through a sorted array of strings. This function may use a comparison
function (such as strcmp) for comparing the search string against the array
strings. This might not be appropriate for all cases. For example, strcmp is
case-sensitive. If we wanted to do the search in a non-case-sensitive manner
then a different comparison function would be needed.
As shown in Listing 5.5, by making the comparison function a parameter
of the search function, we can make the latter independent of the former.

Listing 5.5

6
 1 int BinSearch (char *item, char *table[], int n,
2 int (*Compare)(const char*, const char*))
3 {
4 int bot = 0;
5 int top = n - 1;
6 int mid, cmp;

7 while (bot <= top) {

8 mid = (bot + top) / 2;
9 if ((cmp = Compare(item,table[mid])) == 0)
10 return mid; // return item index
11 else if (cmp < 0)
12 top = mid - 1; // restrict search to lower half
13 else
14 bot = mid + 1; // restrict search to upper half
15 }
16 return -1; // not found
17 }

Annotation
1 Binary search is a well-known algorithm for searching through a sorted
list of items. The search list is denoted by table which is an array of strings
of dimension n. The search item is denoted by item.
2 Compare is the function pointer to be used for comparing item against the
array elements.
7 Each time round this loop, the search span is reduced by half. This is
repeated until the two ends of the search span (denoted by bot and top)
collide, or until a match is found.
9 The item is compared against the middle item of the array.
10 If item matches the middle item, the latter’s index is returned.
11 If item is less than the middle item, then the search is restricted to the
lower half of the array.
14 If item is greater than the middle item, then the search is restricted to the
upper half of the array.
16 Returns -1 to indicate that there was no matching item.
The following example shows how BinSearch may be called with strcmp
passed as the comparison function:
char *cities[] = {"Boston", "London", "Sydney", "Tokyo"};
cout << BinSearch("Sydney", cities, 4, strcmp) << '\n';

This will output 2 as expected. 

4.1.4. References
A reference introduces an alias for an object. The notation for defining
references is similar to that of pointers, except that & is used instead of *. For
example,

7
 double num1 = 3.14;
double &num2 = num1; // num is a reference to num1

defines num2 as a reference to num1. After this definition num1 and num2 both
refer to the same object, as if they were the same variable. It should be
emphasized that a reference does not create a copy of an object, but merely a
symbolic alias for it. Hence, after
num1 = 0.16;

both num1 and num2 will denote the value 0.16.

A reference must always be initialized when it is defined: it should be an
alias for something. It would be illegal to define a reference and initialize it
later.
double &num3; // illegal: reference without an initializer
num3 = num1;

You can also initialize a reference to a constant. In this case a copy of the
constant is made (after any necessary type conversion) and the reference is set
to refer to the copy.
int &n = 1; // n refers to a copy of 1

The reason that n becomes a reference to a copy of 1 rather than 1 itself is

safety. Consider what could happen if this were not the case.
int &x = 1;
++x;
int y = x + 1;

The 1 in the first and the 1 in the third line are likely to be the same object
(most compilers do constant optimization and allocate both 1’s in the same
memory location). So although we expect y to be 3, it could turn out to be 4.
However, by forcing x to be a copy of 1, the compiler guarantees that the object
denoted by x will be different from both 1’s.
The most common use of references is for function parameters. Reference
parameters facilitates the pass-by-reference style of arguments, as opposed to
the pass-by-value style which we have used so far. To observe the differences,
consider the three swap functions in Listing 5.6.

Listing 5.6

8
 1 void Swap1 (int x, int y) // pass-by-value (objects)
2 {
3 int temp = x;
4 x = y;
5 y = temp;
6 }

7 void Swap2 (int *x, int *y) // pass-by-value (pointers)

8 {
9 int temp = *x;
10 *x = *y;
11 *y = temp;
12 }

13 void Swap3 (int &x, int &y) // pass-by-reference

14 {
15 int temp = x;
16 x = y;
17 y = temp;
18 }
Annotation
1 Although Swap1 swaps x and y, this has no effect on the arguments passed
to the function, because Swap1 receives a copy of the arguments. What
happens to the copy does not affect the original.
7 Swap2 overcomes the problem of Swap1 by using pointer parameters
instead. By dereferencing the pointers, Swap2 gets to the original values
and swaps them.
13 Swap3 overcomes the problem of Swap1 by using reference parameters
instead. The parameters become aliases for the arguments passed to the
function and therefore swap them as intended.
Swap3 has the added advantage that its call syntax is the same as Swap1 and
involves no addressing or dereferencing. The following main function
illustrates the differences:

int main (void)

{
int i = 10, j = 20;
Swap1(i, j); cout << i << ", " << j << '\n';
Swap2(&i, &j); cout << i << ", " << j << '\n';
Swap3(i, j); cout << i << ", " << j << '\n';
}

When run, it will produce the following output:

10, 20
20, 10
10, 20 

4.1.5. Typedefs
Typedef is a syntactic facility for introducing symbolic names for data types.
Just as a reference defines an alias for an object, a typedef defines an alias for

9
a type. Its main use is to simplify otherwise complicated type declarations as
an aid to improved readability. Here are a few examples:
typedef char *String;
Typedef char Name[12];
typedef unsigned int uint;

The effect of these definitions is that String becomes an alias for char*, Name
becomes an alias for an array of 12 chars, and uint becomes an alias for
unsigned int. Therefore:

String str; // is the same as: char *str;

Namename; // is the same as: char name[12];
uintn; // is the same as: unsigned int n;

The complicated declaration of Compare in Listing 5.5 is a good candidate

for typedef:
typedef int (*Compare)(const char*, const char*);

int BinSearch (char *item, char *table[], int n, Compare comp)

{
//...
if ((cmp = comp(item, table[mid])) == 0)
return mid;
//...
}

The typedef introduces Compare as a new type name for any function with the
given prototype. This makes BinSearch’s signature arguably simpler.

10