Lesson 5
Pointers & String
Overview
This lesson introduces the most powerful features of the C++ programming
language, the pointer. Pointers are among C++ most difficult capabilities to
master. Pointers enable programs to simulate pass-by-reference and to create
and manipulate dynamic data structures (i.e., data structures that can grow and
shrink), such as linked lists, queues, stacks and trees. In this lesson, a basic
concept of pointers is explained. You will also learn the intimate relationship
among arrays, pointers and string.
Lessons
1. Introduction to Pointer in C++
2. Pointer Variable Declarations and Initialization
3. Passing Arguments to Functions by Reference with Pointers
4. Using const with Pointers
5. Pointer Expressions and Pointer Arithmetic
6. Relationship Between Pointers and Arrays
7. Arrays of Pointers
8. Pointers to Functions
9. Introduction to Pointer-Based String Processing
Lesson 1 – Introduction to Pointer in C++
Objectives:
At the end of this lesson you will be able to:

Describe Pointer
From the earlier lesson we have seen how variables are seen as memory cells
that can be accessed using their identifier. At that point we did not have to care
about the physical location of our data within memory and we simply used the
identifier whenever we wanted to refer to our variable.
The memory of your computer can be imagined as successions of memory cells
where each one of the minimal size that computer manage (one byte). These
single-byte memory cells are numbered in a consecutive way, so as within any
block of memory, every cell has the same number as the previous one plus one.
This way, each cell can be easily located in the memory because it has a unique
address and all the memory cells follow a successive pattern. For example, if we
are looking for cell 1557 we know that it is going to be right between cells 1556
and 1558, exactly one thousand cells after 557 and exactly one thousand cells
before cells 2557.
Reference operator (&)
As soon as we declare a variable the amount of memory needed is assigned for it
at a specific location in memory (its memory address). Normally, a variable directly
contains a specific value. We generally do not actively decide the exact location of
the variable within the panel of cells that we have imagined the memory to be.
This task is automatically performed by the operating system during runtime.
However in some cases we may be interested in knowing the address where our
variable is being stored during runtime in order to operate with relative positions to
it.
The address that locates a variable within memory is what we call a reference to
that variable. This reference to a variable can be obtained by preceding the
identifier of a variable with an ampersand sign (&), known as reference operator,
and which can be literally translated as “address of”. The address operator (&) is
a unary operator that returns the memory address of its operand. For example:
cat = &snowy;
This would assign to cat the address of variable snowy, since when preceding the
name of the variable snowy with the reference operator (&) we are no longer
talking about the content of the variable itself, but about its reference (i.e., its
address in memory).
From this point onward we will assume that snowy is placed during runtime in the
memory address 1557. This number (1557) is just an assumption we are inventing
now in order to help clarify some concepts in this lesson, where in reality we
cannot know before the runtime the real value the address of a variable will have
in memory.
Consider the following code fragment:
snowy = 25;
meowy = snowy;
cat = &snowy;
The values contained in each variable after the execution of this, are shown in the
following diagram:
snowy
25
1556
1557
1558
&
Meowy
25
cat
1557
First, we have assigned the value of 25 to snowy ( a variable whose address in
memory we have assumed to be 1557).
The second statement copied to meowy the content of the variable snowy (which
is 25). This is a standard statement assignment operation, as we have done so
many times before.
Finally the third statement copies to cat not the value contained in snowy but a
reference to it (i.e., its address, which we have assumed to be 1557). The reason
is that in this third assignment operation we have preceded the identifier snowy
with the reference operator (&), so we were no longer referring to the value to
snowy but to its reference (its address in memory).
The variable that stores the reference to another variable (like cat in the previous
example) is what we call a pointer. This means pointer is simply an address.
Pointers are a very powerful feature of the C++ language that has many uses in
advanced programming. Further ahead, we will see how this type of variable is
used and declared.
Dereference operator (*)
We have just seen that a variable which stores a reference to another variable is
called a pointer. Pointers are said to ‘point to’ the variable whose reference they
store.
Using a pointer we can directly access the value stored in the variable which it
points to. To do this, we have to precede the pointer’s identifier with an asterisk
(*), which acts as derefence operator and that can be literally translated to “value
pointed by”.
Therefore, the following with the values of the previous example, if we write:
glowy = *cat;
(we can read the above as: “glowy equal to value pointed by cat”) glowy would
take the value 25, since cat is 1557, and the value pointed by 1557 is 25.
cat
1557
1556
1557
1558
25
25
glowy
Important point to note: You must clearly differentiate that the expression cat
refers to the value 1557, while *cat (with an asterisk * preceding the identifier)
refers to the value stored at address 1557, which in this case is 25. Also notice the
difference of including or not including the dereference operator.
beth = cat;
beth = *cat;
Notice the difference between the reference and dereference operators:

& is the refence operator and can be read as “address of”

* is the dereference operator and can be read as “value pointed by”
Thus, the above concludes that a variable referenced with & can be dereferenced
with *.
Earlier we performed the following two assignment operations:
snowy = 25;
cat = &snowy;
Right after these two statements, all of the following expressions would give true
as result:
snowy == 25
&snowy == 1557
cat == 1557
*cat== 25
 The first expression is quite clear considering that the assignment operation
performed on snowy was snowy=25.
 The second one uses the reference operator (&), which returns the address
of variable snowy, which we assumed it to have a value of 1557.
 The third one is somewhat obvious since the second expression was true
and the assignment operation performed on cat was cat=&snowy.
 The fourth expression uses the dereference operator (*) that, as we have
just seen can be read as “value pointed by”, and the value pointed by cat is
indeed 25.
So finally, you may also infer that for as long as the address pointed to cat
remains unchanged the following expression will also be true:
*cat == snowy
Lesson 2 – Pointer Variable Declarations and Initialization
Objectives:
At the end of this lesson you will be able to:

Use pointers.
Pointer Declaration
Pointers like any other variables must be declared before they can be used.
Due to the ability of a pointer to directly refer to the value that it points to, it
becomes necessary to specify in its declaration which data type a pointer is going
point to. It is not the same thing to point to a char than to point to an int or a float.
The declaration of pointers follows this format:
type * name;
where type is the data type of the value that the pointer is intended to point to.
This type is not the type of the pointer itself! but the type of the data the pointer
points to. For example:
int * my_integer;
char * my_character;
float * my_greatnumber;
These are three declarations of pointers. Each one is intended to point to a
different data type, but in fact all of them are pointers and all of them will occupy
the same amount of space in memory (the size in memory of a pointer depends
on the platform where the code is going to run). Nevertheless, the data to which
they point to do not occupy the same amount of space nor are of the same type:

the first one points to an int,

the second one to a char

the third one to a float.
Therefore, although these three example variables are all of them pointers which
occupy the same size in memory, they are said to have different types: int*, char*
and float* respectively, depending on the type they point to.
The asterisk sign (*) that we use when declaring a pointer only means that it is a
pointer (it is part of its type compound specifier), and should not be confused with
the dereference operator that we have seen a bit earlier, but which is also written
with an asterisk (*). They are simply two different things represented with the
same sign.
Here is an example of the use of pointers:
// First pointer program
#include <iostream>
using namespace std;
int main ()
{
int value_one, value_two;
int * my_pointer;
my_pointer = &value_one;
*my_pointer = 10;
my_pointer = &value_two;
*my_pointer = 20;
cout << "firstvalue is " << value_one << endl;
cout << "secondvalue is " << value_two << endl;
return 0;
}
Output:
firstvalue is 10
secondvalue is 20
Notice that even though we have never directly set a value to either value_one or
value_two, both end up with a value set indirectly through the use of my_pointer.
This is the procedure:
First, we have assigned as value of my_pointer a reference to value_one using
the reference operator (&). And then we have assigned the value 10 to the
memory location pointed by my_pointer, that because at this moment is pointing to
the memory location of value_one, this in fact modifies the value of value_one.
In order to demonstrate that a pointer may take several different values during the
same program, the process is repeated with value_two and that same pointer,
my_pointer.
The example below elaborates more the above points.
// more pointers
#include <iostream>
using namespace std;
int main ()
{
int value_one = 5, value_two = 15;
int * p1, * p2;
p1 = &value_one; // p1 = address of firstvalue
p2 = &value_two; // p2 = address of secondvalue
*p1 = 10;
// value pointed by p1 = 10
*p2 = *p1;
// value pointed by p2 = value pointed by p1
p1 = p2;
// p1 = p2 (value of pointer is copied)
*p1 = 20;
// value pointed by p1 = 20
cout << "firstvalue is " << value_one << endl;
cout << "secondvalue is " << value_two << endl;
return 0;
}
The output:
firstvalue is 10
secondvalue is 20
You can see comment is included on each line how the code can be read:
ampersand (&) as "address of" and asterisk (*) as "value pointed by".
Notice that there are expressions with pointers p1 and p2, both with and without
dereference operator (*). The meaning of an expression using the dereference
operator (*) is very different from one that does not: When this operator precedes
the pointer name, the expression refers to the value being pointed, while when a
pointer name appears without this operator, it refers to the value of the pointer
itself (i.e. the address of what the pointer is pointing to).
Another thing that may call your attention is the line:
int * p1, * p2;
This declares the two pointers used in the previous example. But notice that there
is an asterisk (*) for each pointer, in order for both to have type int* (pointer to int).
Otherwise, the type for the second variable declared in that line would have been
int (and not int*) because of precedence relationships. If we had written:
int * p1, p2;
p1 would indeed have int* type, but p2 would have type int (spaces do not matter
at all for this purpose). This is due to operator precedence rules. But anyway,
simply remembering that you have to put one asterisk per pointer is enough for
most pointer users.
Pointer Initialization
When declaring pointers we may want to explicitly specify which variable we want
them to point to:
int number;
int *mommy = &number;
The behavior of this code is equivalent to:
int number;
int *mummy;
mummy = &number;
When a pointer initialization takes place we are always assigning the reference
value to where the pointer points (mummy), never the value being pointed
(*mummy). You must consider that at the moment of declaring a pointer, the
asterisk (*) indicates only that it is a pointer, it is not the dereference operator
(although both use the same sign: *). Remember, they are two different functions
of one sign. Thus, we must take care not to confuse the previous code with:
int number;
int *mummy;
*mummy = &number;
that is incorrect, and anyway would not have much sense in this case if you think
about it.
As in the case of arrays, the compiler allows the special case that we want to
initialize the content at which the pointer points with constants at the same
moment the pointer is declared:
char * berry = "hello";
In this case, memory space is reserved to contain "hello" and then a pointer to the
first character of this memory block is assigned to terry. If we imagine that "hello"
is stored at the memory locations that start at addresses 1503, we can represent
the previous declaration as:
‘h’
1503
‘e’
1504
‘l’
1505
‘l’
1506
‘o’
1507
‘\0’
1508
It is important to indicate that berry contains the value 1503, and not 'h' nor "hello",
berry1503 indeed is the address of both of these.
although
1503
The pointer berry points to a sequence of characters and can be read as if it was
an array (remember that an array is just like a constant pointer). For example, we
can access the fifth element of the array with any of these two expression:
*(berry+4)
berry[4]
Both expressions have a value of 'o' (the fifth element of the array).
Void Pointer
The void type of pointer is a special type of pointer. In C++, void represents the
absence of type, so void pointers are pointers that point to a value that has no
type (and thus also an undetermined length and undetermined dereference
properties).
This allows void pointers to point to any data type, from an integer value or a float
to a string of characters. But in exchange they have a great limitation: the data
pointed by them cannot be directly dereferenced (which is logical, since we have
no type to dereference to), and for that reason we will always have to cast the
address in the void pointer to some other pointer type that points to a concrete
data type before dereferencing it.
One of its uses may be to pass generic parameters to a function:
// increaser
#include <iostream>
using namespace std;
void increase (void* data, int pointer_size)
{
if ( pointer_size == sizeof(char) )
{ char* pointer_char; pointer_char=(char*)data; ++(*pointer_char); }
else if (pointer_size == sizeof(int) )
{ int* pointer_int; pointer_int=(int*)data; ++(*pointer_int); }
}
int main ()
{
char a = 'x';
int b = 1503;
increase (&a,sizeof(a));
increase (&b,sizeof(b));
cout << a << ", " << b << endl;
return 0;
}
Output:
y, 1504
sizeof is an operator integrated in the C++ language that returns the size in bytes
of its parameter. For non-dynamic data types this value is a constant. Therefore,
for example, sizeof(char) is 1, because char type is one byte long.
Null Pointer
A null pointer is a regular pointer of any pointer type which has a special value that
indicates that it is not pointing to any valid reference or memory address. This
value is the result of type-casting the integer value zero to any pointer type.
int * p;
p = 0;
// p has a null pointer value
Do not confuse null pointers with void pointers. A null pointer is a value that any
pointer may take to represent that it is pointing to "nowhere", while a void pointer
is a special type of pointer that can point to somewhere without a specific type.
One refers to the value stored in the pointer itself and the other to the type of data
it points to.
Lesson 3 – Passing Arguments to Functions by Reference with Pointers
Objectives:
At the end of this lesson you will be able to:

pass arguments using pointers
There are three ways in C++ to pass arguments to a function:
1. pass-by-value
2. pass-by-reference with reference arguments
3. pass-by-reference with pointer arguments
In this lesson, we will concentrate on pass-by-reference with pointer arguments.
Return can be used to return one value from a called function to a caller (or to
return control from a called function without passing back a value). Arguments can
be passed to a function using reference arguments. Such arguments enable the
function to modify the original values of the arguments (thus more than one value
can be “returned” from a function). Reference arguments also enable programs to
pass large data objects to a function and avoid the overhead of passing the
objects by value (which of course, requires making a copy of the object). Pointers,
like references also can be used to modify one or more variables in the caller or to
pass pointers to large data objects to avoid the overhead of passing the objects by
value.
In C++, we can use pointers and the indirection operator to simulate pass-byreference. When calling a function with arguments that should be modified, the
addresses of the arguments are passed. This is normally accomplished by
applying the address operator (&) to the name of the variable whose value will be
modified.
Array are not passed using operator & because the name of the array is the
starting location in memory of the array (i.e. an array name is already a poiinter).
The name of an array is equivalent to &array_Name [0[. When the address of a
variable is passed to a function, the indirection operator (*) can be used in the
function to form a synonym (i.e. an alias or a nickname) for the name of the
variable – this in turn can be used to modify the value of the variable at that
location in the caller’s memory.
Examples of code for cube a variable using pass-by-value.
1
/*
2
Cube a variable using call-by-value
3
*/
4
5
#include <stdio.h>
6
7
int cubeByValue( int );
/* prototype */ Function Prototype
8
9
int main()
10
{
11
int number = 5;
Initialize variable
12
);
);
13
printf( "The original value of number is %d", number
14
number = cubeByValue( number );
15
printf( "\nThe new value of number is %d\n", number
Call Function
16
17
18
return 0;
}
19
20
int cubeByValue( int n )
21
{
22
23
return n * n * n;
Define Function
/* cube number in main */
}
Output:
The original value of number is 5
The new value of number is 125
The above example passes variable number by value to function cubeByValue.
Function cubeByValue cubes its arguments and passes the new value back to
main using a return statement. The new value is assigned to number in main.
Note that you have the opportunity to examine the result of the function call before
modifying variable number’s value. For example, in this program we could have
stored the result of cubeByValue in another variable, examined its value and
assigned the result to number after determining whether the returned value was
reasonable.
The above code for call-by-value can be analyzed as below:
Before main calls cubeByValue:
int main()
{
Int cubeByValue( int n)
number
int number = 5;
{
Return n * n * n;
5
}
n
number = cubeByValue (number);
undefined
}
After cubeByValue receives the call:
int main()
{
number
int number = 5;
5
Int cubeByValue(
int n
)
{
Return n * n * n;
number = cubeByValue (number);
}
n
}
5
After cubeByValue cubes parameter n and before cubeByValue returns to main:
int main()
{
Int cubeByValue( int n)
number
int number = 5;
{
Return
5
125
n * n * n;
}
number = cubeByValue (number);
n
5
}
After cubeByValue returns to main and before assigning the result to number:
int main()
{
Int cubeByValue( int n)
number
5
{
int number = 5;
number =
Return n * n *n;
125
cubeByValue (number);
}
n
undefined
}
After main completes the assignment to number:
int main()
{
Int cubeByValue( int n)
number
int number = 5;
{
Return n * n *n;
5
125
125
number = cubeByValue (number);
}
n
undefined
}
Examples of code for cube a variable using pass-by-reference with a pointer
argument.
2
/* Cube a variable using call-by-reference
3
with a pointer argument */
4
5
#include <stdio.h>
6
7
Function Prototype
void cubeByReference( int * );
8
9
int main()
10
{
11
int number = 5;
/* prototype */
Notice that the function prototype takes a pointer to an
integer ( int * ).
Initialize variables
12
);
);
13
printf( "The original value of number is %d", number
14
cubeByReference( &number ); Call function
15
printf( "\nThe new value of number is %d\n", number
16
17
18
Notice how the address of number is
given - cubeByReference expects a
pointer (an address of a variable).
return 0;
}
Inside cubeByReference, *nPtr is used (*nPtr is number).
19
20
void cubeByReference( int *nPtr )
21
{
22
main */
23
*nPtr = *nPtr * *nPtr * *nPtr;
Define function
/* cube number in
}
Output
The original value of number is 5
The new value of number is 125
The above code passes variable number by value to function cubeByReference
with a pointer argument – the address of number is passed to the function.
Function cubeByReference specifies parameter nPtr (a pointer to int) to receive its
argument. The function dereferences the pointer and cubes the value to which
nPtr points. This changes the value of number in main.
A function receiving an address as an argument must define a pointer parameter
to receive the address. For example, the header for function cubeByReference
specifies that cubeByReference receives the address of an int variable (i.e. a
pointer to an int) as an argument, stores the address locally in nPtr and does not
return a value.
The function prototype for cubeByReference contains int * in parentheses. As with
other variable types, it is not necessary to include names of pointer parameters in
function prototypes. Parameter names included for documentation purposes are
ignored by the compiler.
The above code for call-by-reference can be analyzed as below:
Before main calls cubeByReference:
int main()
{
Int cubeByReference( int *nPtr)
number
int number = 5;
{
*nPtr = *nPtr * *nPtr * *nPtr;
5
}
nPtr
cubeByReference ( &number );
undefined
}
After cubeByReference receives the call and before *nPtr is cubed:
int main()
{
number
int number = 5;
5
int
cubeByReference(
int *nPtr
{
cubeByReference ( &number );
*nPtr = *nPtr * *nPtr * *nPtr;
}
}
call establishes this pointer
nPtr
After cubeByReference receives the call and before *nPtr is cubed:
int main()
{
number
125
int cubeByReference( int *nPtr)
)
int number = 5;
{
125
*nPtr = *nPtr * *nPtr * *nPtr;
cubeByReference ( &number );
}
}
called function modifies
caller’s variable
nPtr
In the function header and in the prototype for a function that expects a singlesub-scripted array as an argument, the pointer notation in the parameter list of
cubeByReference may be used. The compiler does not differentiate between a
function that receives a pointer and a function that receives a single-subscripted
array. This, of course, means that the function must “know” when it is receiving an
array or simply a single variable for which it is to perform pass-by-reference. When
the compiler encounters a function parameters for a single-subscripted array of
the form int b[ ], the compiler converts the parameter to the pointer notation int *
const b (pronounced “b’ is a constant pointer to an integer”). Both forms of
declaring a function parameter as single-subscripted array are interchangeable.
Lesson 4 – Using const with Pointers
Objectives:
At the end of this lesson you will be able to:

Use const qualifier for static data.
Contant pointers are something that many people simply don't use. If you have a
value in your program and it should not change, or if you have a pointer and you
don't want it to be pointed to a different value, you should make it a constant with
the const keyword.
The const qualifier enables the programmer to inform the compiler that the value
of a particular variable should not be modified.
A const pointer cannot be reassigned to point to a different object from the one it
is initially assigned, but it can be used to modify the object that it points to (called
the "pointee"). (Reference variables are thus an alternate syntax for const
pointers.) A pointer to a const object, on the other hand, can be reassigned to
point to another object of the same type or of a convertible type, but it cannot be
used to modify any object. A const pointer to a const object can also be declared
and can neither be used to modify the pointee nor be reassigned to point to
another object.
The const qualifier can be used to enforce the principle of least privilege. Using
the principle of least privilege to properly design software can greatly reduce
debugging time and improper side effects and can make a program easier to
modify and maintain.
There are four ways to pass a pointer to a function:
1. a nonconstant pointer to nonconstant data
2. a nonconstant pointer to constant data
3. a constant pointer to non-constant data
4. a constant ponter to constant data.
Each combination above provides a different level of access privileges.
There are generally two places that the const keyword can be used when
declaring a pointer. Consider the following declaration:
char A_char = 'A';
char * myPtr = &A_char;
This is a simple declaration of the variable myPtr. myPtr is a pointer to a character
variable and in this case points to the character 'A'.
Don't be confused about the fact that a character pointer is being used to point to
a single character—this is perfectly legal! Not every character pointer has to point
to a string.
Now consider the following three declarations assuming that char_A has been
defined as a type char variable.:
const char * myPtr = &char_A;
char * const myPtr = &char_A;
const char * const myPtr = &char_A;
What is the difference between each of the valid ones? Do you know?
They are all three valid and correct declarations. Each assigns the addres of
char_A to a character pointer. The difference is in what is constant.
The first declaration:
const char * myPtr
declares a pointer to a constant character. You cannot use this pointer to change
the value being pointed to:
char char_A = 'A';
const char * myPtr = &char_A;
*myPtr = 'J';
// error - can't change value of *myPtr
The second declaration,
char * const myPtr
declares a constant pointer to a character. The location stored in the pointer
cannot change. You cannot change where this pointer points:
char char_A = 'A';
char char_B = 'B';
char * const myPtr = &char_A;
myPtr = &char_B;
// error - can't change address of myPtr
The third declares a pointer to a character where both the pointer value and the
value being pointed at will not change.
Lesson 5 – Pointer Expressions and Pointer Arithmetic
Objectives:
At the end of this lesson you will be able to:

use arithmetic operation with pointers and differentiate the normal
arithmetic operations and pointer arithmetic.
Pointers are valid operands in arithmetic expression, assignment expressions and
comparison expressions. However, not all the operators normally used in these
expressions are valid with pointer variables.
To conduct arithmetical operations on pointers is a little different than to conduct
them on regular integer data types. To begin with, only addition and subtraction
operations are allowed to be conducted with them, the others make no sense in
the world of pointers. But both addition and subtraction have a different behavior
with pointers according to the size of the data type to which they point.
When we saw the different fundamental data types, we saw that some occupy
more or less space than others in the memory. For example, let's assume that in a
given compiler for a specific machine, char takes 1 byte, short takes 2 bytes and
long takes 4.
Suppose that we define three pointers in this compiler:
char *mychar;
short *myshort;
long *mylong;
and that we know that they point to memory locations 1000, 2000 and 3000
respectively.
So if we write:
mychar++;
myshort++;
mylong++;
mychar, would contain the value 1001. But not so obviously, myshort would
contain the value 2002, and mylong would contain 3004, even though they have
each been increased only once. The reason is that when adding one to a pointer
we are making it to point to the following element of the same type with which it
has been defined, and therefore the size in bytes of the type pointed is added to
the pointer.
This is applicable both when adding and subtracting any number to a pointer. It
would happen exactly the same if we write:
mychar = mychar + 1;
myshort = myshort + 1;
mylong = mylong + 1;
Both the increase (++) and decrease (--) operators have greater operator
precedence than the dereference operator (*), but both have a special behavior
when used as suffix (the expression is evaluated with the value it had before being
increased). Therefore, the following expression may lead to confusion:
*p++
Because ++ has greater precedence than *, this expression is equivalent to
*(p++). Therefore, what it does is to increase the value of p (so it now points to the
next element), but because ++ is used as postfix the whole expression is
evaluated as the value pointed by the original reference (the address the pointer
pointed to before being increased).
Notice the difference with:
(*p)++
Here, the expression would have been evaluated as the value pointed by p
increased by one. The value of p (the pointer itself) would not be modified (what is
being modified is what it is being pointed to by this pointer).
If we write:
*p++ = *q++;
Because ++ has a higher precedence than *, both p and q are increased, but
because both increase operators (++) are used as postfix and not prefix, the value
assigned to *p is *q before both p and q are increased. And then both are
increased. It would be roughly equivalent to:
*p = *q;
++p;
++q;
Always use parentheses () in order to avoid unexpected results and to give more
legibility to the code.
Lesson 6 – Relationship Between Pointers and Arrays
Objectives:
At the end of this lesson you will be able to:

differentiate between pointers and array
The concept of array is very much bound to the one of pointer. In fact, the
identifier of an array is equivalent to the address of its first element, as a pointer is
equivalent to the address of the first element that it points to, so in fact they are
the same concept. For example, supposing these two declarations:
int numbers [20];
int * p;
The following assignment operation would be valid:
p = numbers;
After that, p and numbers would be equivalent and would have the same
properties. The only difference is that we could change the value of pointer p by
another one, whereas numbers will always point to the first of the 20 elements of
type int with which it was defined. Therefore, unlike p, which is an ordinary pointer,
numbers is an array, and an array can be considered a constant pointer.
Therefore, the following allocation would not be valid:
numbers = p;
Because numbers is an array, so it operates as a constant pointer, and we cannot
assign values to constants.
Due to the characteristics of variables, all expressions that include pointers in the
following example are perfectly valid:
// more pointers
#include <iostream>
using namespace std;
int main ()
10, 20, 30, 40, 50,
{
int numbers[5];
int * p;
p = numbers; *p = 10;
p++; *p = 20;
p = &numbers[2]; *p = 30;
p = numbers + 3; *p = 40;
p = numbers; *(p+4) = 50;
for (int n=0; n<5; n++)
cout << numbers[n] << ", ";
return 0;
}
In the chapter about arrays we used brackets ([]) several times in order to specify
the index of an element of the array to which we wanted to refer. Well, these
bracket sign operators [] are also a dereference operator known as offset
operator. They dereference the variable they follow just as * does, but they also
add the number between brackets to the address being dereferenced. For
example:
a[5] = 0;
*(a+5) = 0;
// a [offset of 5] = 0
// pointed by (a+5) = 0
These two expressions are equivalent and valid both if a is a pointer or if a is an
array.
Lesson 7 –Arrays of Pointers
Objectives:
At the end of this lesson you will be able to:

use pointer in array of strings
Arrays may contain pointers. A common use of such a data structure is to form an
array of strings, referred to simply as a sting array. Each entry in the array is a
string, but in C++ a sting is essentially a pointer to its first character, so each entry
in an array of strings is actually a pointer to the first character of a string. Consider
the declaration of string array suit that might be useful in representing a deck of
cards:
const char *suit [ 4 ] =
{ “Hearts”, “Diamonds”, “Clubs”, “Spades” };
The suit [4] portion of the declaration indicates an array of four elements. The char
* portion of the declaration indicates that each element of array suit is of type
“pointer to char”. The foru values to be placed in the array are “Hearts”,
“Diamonds”, “Clubs” and “Spades”. Each of these is stored in memory as a nullterminated character string that is one character longer than the number of
characters between quotes. The four strings are being placed in the suit array,
only pointers are actually stored in the array. Each pointer points to the first
character of its corresponding string. Thus, even though the suit array is fixed in
size, it provides access to character strings of any length. This flexibility is one
example of C++’s powerful data structuring capabilities.
suit[0]
’H’
’e’
’a’
’r’
’t’
’s’
’\0’
suit[1]
’D’
’i’
’a’
’m’
’o’
’n’
’d’
suit[2]
’C’
’l’
’u’
’b’
’s’
’\0’
suit[3]
’S’
’p’
’a’
’d’
’e’
’s’
’s’
’\0’
’\0’
The suit string could be placed into a double-subscripted array in which each row
represents one suit and each column represents one of the letters of a suit name.
Such a data structure must have a fixed number of columns per row, and that
number must be as large as the largest string. Therefore, considerable memory is
wasted when a large number of strings is stored with most strings shorter than the
longest string.
Sting arrays are commonly used with command-line arguments that are passed to
function main when a program begins execution. Such arguments follow the
program name when a program is executed from the command line. A typical use
of command line arguments is to pass options to a program. For example, from
the command line on a Windows computer, the user can type
dir /p
to list the contents of the current directory and pause after each screen of
information. When the dir command executes, the option /p is passed to dir as a
command line argument. Such arguments are placed in a string array that main
receives as an argument.
Lesson 8 –Pointers to Functions
Objectives:
At the end of this lesson you will be able to:

use pointers to functions
C++ allows operations with pointers to functions. The typical use of this is for
passing a function as an argument to another function, since these cannot be
passed dereferenced. In order to declare a pointer to a function we have to
declare it like the prototype of the function except that the name of the function is
enclosed between parentheses () and an asterisk (*) is inserted before the name:
// pointer to functions
#include <iostream>
using namespace std;
int addition (int a, int b)
{ return (a+b); }
int subtraction (int a, int b)
{ return (a-b); }
8
int
operation
(int
x,
int
y,
int
(*functocall)(int,int))
{
int g;
g = (*functocall)(x,y);
return (g);
}
int main ()
{
int m,n;
int (*minus)(int,int) = subtraction;
m = operation (7, 5, addition);
n = operation (20, m, minus);
cout <<n;
return 0;
}
In the example, minus is a pointer to a function that has two parameters of type
int. It is immediately assigned to point to the function subtraction, all in a single
line:
int (* minus)(int,int) = subtraction;
References:
1. Paul J. Deitel & H.M. Deitel () C++ How to Program (6th Edition). Prentise
Hall
2. What is const pointer? http://wiki.answers.com/Q/What_is_const_pointer
3. Pointers and const http://www.learncpp.com/cpp-tutorial/610-pointers-andconst/
4. Pointers
in
C++
http://mycplus.com/tutorials/cplusplus-
programming-tutorials/pointers-2/3/
5. More on pointers in C
http://www.cse.lehigh.edu/~brian/course/2007/cunix/notes/more
pointers.html