Pointer variables, the reference (&) and dereference (*) operators

Reference variables.... or pointer variables (pointers)
- It is very common that a program need to manipulate addresses of variables
  Example:
- Just like programs need to define int type variables to help programmers store and manipulate integer values, C++ allows the programmer to define a special type of variables to store address values
- An address is also known as a reference
- NOTE:

Defining reference variables

Syntax to define a reference variable

Examples defining pointer variables:

int * p; // variable p holds an address of an int variable double * q; // variable q holds an address of a double variable

NOTE:

(int *) p; (double *) q;

(int *) means: reference (address) to an int
(double *) means: reference (address) to a double

The reference and dereference operators
- Operators:
- Example: arithmetic operators such as +, -, * and /
- We will now look at 2 unusual operators in the C/C++ programming language that is not usually found in other high level programming languages:
  These operators belongs to low-level programming languages (such as assembler programming)
  They are included in C/C++ because C/C++ is a system programming language

The reference Operator &

The reference operator &:

The reference Operator & operates on a (single) variable
It returns the address of that variable

Example:

Let: x be any variable Then: & x is the address of the variable x

Example program:

int i1, i2; short s1, s2; char c1, c2; float f1, f2; double d1, d2; int main(int argc, char *argv[]) { cout << "Address of i1 = " << (unsigned int) &i1 << "\n"; cout << "Address of i2 = " << (unsigned int) &i2 << "\n"; cout << "Address of s1 = " << (unsigned int) &s1 << "\n"; cout << "Address of s2 = " << (unsigned int) &s2 << "\n"; cout << "Address of c1 = " << (unsigned int) &c1 << "\n"; cout << "Address of c2 = " << (unsigned int) &c2 << "\n"; cout << "Address of f1 = " << (unsigned int) &f1 << "\n"; cout << "Address of f2 = " << (unsigned int) &f2 << "\n"; cout << "Address of d1 = " << (unsigned int) &d1 << "\n"; cout << "Address of d2 = " << (unsigned int) &d2 << "\n"; }

Example Program: (Demo above code)
- Prog file: click here

Reference variables and reference operator

Reference variables are often used in conjuction with the reference operator in the following manner:

int a; // a can hold an integer value int *p; // p can hold an address of an integer variable &a // is the address of the integer variable a p = &a; // p now contains the address of the // integer variable a // We say that: "p points to a"

Graphical depiction of the above situation:
From the above figure, you can see what we say that "p points to a"

The dereference Operator *

The de-reference operator *:

The de-reference Operator * operates on an address (= an unsigned integer !)
The de-reference Operator * returns the variable at that address

Example:

Let: 3456 be an address (an integer) Then: * 3456 is the variable at the address 3456

But it is not that simple.... there is a little problem:

You are given an address...
The computer has no idea what type of value is stored at that address !!!
We must provide typing information along with the address to allow the computer to do its job...

Expressing the typing information :

The de-reference operator * is preceeded by typing information:

(type *) Examples: (int *) 3456 is the int value stored at the address (double *) 3456 is the double value stored at the address

Example program:

int i1 = 1234, i2; short s1 = -54, s2; char c1, c2; float f1 = 3.14, f2; double d1 =2.718, d2; int main(int argc, char *argv[]) { cout << (unsigned int) &i1 << "\n"; cout << "int value at 136760 = " << * (int*)136760 << "\n"; cout << (unsigned int) &f1 << "\n"; cout << "float value at 136764 = " << * (float*)136764 << "\n"; cout << (unsigned int) &d1 << "\n"; cout << "double value at 136768 = " << * (double*)136768 << "\n"; }

Example Program: (Demo above code)
- Prog file: click here

The de-reference operator and reference variables

The de-reference operator * works naturally with a reference variable (that contains an address):

int * p; // p can hold an address of an integer variable p // is an address (of an integer variable) *p // is the integer variable at that address

NOTE:

Because a reference variable in C++ has a type, the de-reference operator * will return a variable of the same type

Examples using pointer variables:

int a; int * p; // variable p holds an address of an int variable p = &a; // &a = the address of the integer variable a // p now contains the address of the integer variable a // We say: p "points to" a *p = 1234; // Put the value 1234 into the (integer) variable // pointed to by p // The variable a will be changed !!!

Example Program: (Demo above code)
- Prog file: click here

Warning:

You should make (int *) type reference (pointer) variable point to an integer variable.
A (double *) type pointer variable point to a double variable, etc, etc.

In C++, it is illegal to do this without casting:

double a; int* p; // p references an integer values variable p = &a; // make p point to a double valued variable.... // ILLEGAL (Compile error) !!!