COMPUTER PROGRAMMING
LECTURE # 10: POINTERS - A
BSE 1
Joddat Fatima
1
[email protected]
Department of C&SE
Bahria University Islamabad
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).
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.
2
It can be literally translated as "address of".
EXAMPLE
For example:
ted = &andy;
This would assign to ted the address of variable andy, since when
preceding the name of the variable andy 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).
Assume that andy is placed during runtime in the memory 3
address 1776.
EXAMPLE CONT…
andy = 25;
fred = andy;
ted = &andy;
4
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 simply have to precede the pointer's identifier
with an asterisk (*), which acts as dereference operator. 5
EXAMPLE
beth = *ted;
The expression ted refers to the value 1776, while *ted
refers to the value stored at address 1776, which in this
case is 25.
6
& AND * DIFFERENCE
Difference between the reference and dereference
operators:
& is the reference operator and can be read as "address of"
* is the dereference operator and can be read as "value
pointed by"
7
POINTERS
8
INTRODUCTION
We have already seen how variables are seen as memory cells that
can be accessed using their identifiers.
This way we did not have to care about the physical location of our
data within memory, we simply used its identifier
A pointer is the memory address of a variable
Memory addresses can be used as names for variables
If a variable is stored in three memory locations, the address of the
first can be used as a name for the variable.
When a variable is used as a call-by-reference argument, its address
is passed 9
WHY POINTERS
They tell where to find the variable
An address used to tell where a variable is stored in memory
is a pointer
Pointers "point" to a variable by telling where the variable is
located
Accessing array elements
For argument passing
Obtaining memory location
For different data structures
10
DECLARING POINTERS
Pointer variables must be declared to have a pointer type
Example: To declare a pointer variable p that can "point" to a
variable of type double:
double *p;
The asterisk identifies p as a pointer variable
To declare multiple pointers in a statement, use the asterisk
before each pointer variable
Example:
int *p1, *p2, v1, v2;
p1 and p2 point to variables of type int
11
v1 and v2 are variables of type int
ASSIGNING POINTERS
The assignment operator = is used to assign the value of
one pointer to another
Example:
v1 = 0; p1 = &v1; *p1 = 42; output:
cout << v1 << endl; 42
cout << *p1 << endl; 42
If p1 still points to v1 then p2 = p1;
causes *p2, *p1, and v1 all to name the same variable
12
CAUTIOUS!!!! POINTER ASSIGNMENTS
Some care is required making assignments to pointer variables
p1= p3; // changes the location that p1 "points" to
*p1 = *p3; // changes the value at the location that // p1 "points" to
13
EXAMPLE
#include <iostream>
using namespace std;
int main ()
{
int firstvalue, secondvalue;
int * mypointer;
mypointer = &firstvalue;
*mypointer = 10;
mypointer = &secondvalue;
*mypointer = 20;
cout << "firstvalue is " << firstvalue << endl;
cout << "secondvalue is " << secondvalue << endl;
return 0; 14
}
EXAMPLE EXPLANATION
Notice that even though we have never directly set a value to
either firstvalue or secondvalue, both end up with a value set
indirectly through the use of mypointer.
First, we have assigned as value of mypointer a reference to
firstvalue using the reference operator (&).
Then we have assigned the value 10 to the memory location
pointed by mypointer, that because at this moment is
pointing to the memory location of firstvalue, this in fact
modifies the value of firstvalue.
15
EXAMPLE 2
#include <iostream>
using namespace std;
int main ()
{
int firstvalue = 5, secondvalue = 15;
int * p1, * p2;
p1 = &firstvalue; // p1 = address of firstvalue
p2 = &secondvalue; // 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 " << firstvalue << endl;
cout << "secondvalue is " << secondvalue << endl;
return 0; 16
}
POINTERS AND ARRAYS
The concept of array is very much bound to the one of pointer.
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:
17
p = numbers;
POINTERS AND ARRAYS CONT…
Now, 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.
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,
18
and we cannot assign values to constants.
EXAMPLE
using namespace std;
int main ()
{
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; 19
}
OFFSET!!
In 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 [offset of 5] = 0
*(a+5) = 0; // pointed by (a+5) = 0
These two expressions are equivalent and valid both if a is a pointer or if a is 20
an array.
