กก

Section 3.3 Pointers

We have already seen how variables are memory cells which we can access by their name. But these variables are stored in concrete places of the computer memory. For our programs the computer memory is only a succession of cells with a size of 1 byte (the minimum size for a datum) each one with a unique address.

A good simile for the computer memory can be a street of any city. On a street all houses are numbered consecutively with an unique identifier so if we talk about 27th of Sesame Street we will be able to find that place without loss, since it must be only one house with that number and, in addition, we know that that house will be between houses 26 and 28 (or between houses 25 and 29, depending on the city).

In the same way in which houses of a street are numbered, the operating system organizes the memory with unique and consecutive numbers, so that if we talk about location 1776 in the memory, we know that there is only one location with that address and also that is between addresses 1775 and 1777.

Direction (or dereference) operator (&).

This can be done by writting an ampersand(&), which literally means "direction of" just before the variable identifier. For example:

ted = &andy;

We are going to suppose that andy has been placed in the memory address 1776 and that we write the following:

andy = 25;
fred = andy;
ted = &andy;

The variable that stores the address of another variable (like ted in the previous example) is what we call a pointer. In C++ pointers have certain virtues and they are used very often. More ahead we will see how this type of variables are declared.

Reference or indirección operator (*)

beth = *ted;

beth = ted;   // beth equal to ted ( 1776 )
beth = *ted;  // beth equal to value pointed by ted ( 25 )

Operator of direction or dereference (&) It is used as a variable prefix and can be translated as "address of", thus: &variable1 can be read as "address of variable1" Operator of reference or indirection (*) It indicates that what has to be evaluated is the content pointed by the expression considered as an address. It can be translated by "value pointed by". * mypointer can be read as "value pointed by mypointer".

Once at this point, and following with the same example above:

andy = 25;
ted = &andy;

andy == 25
&andy == 1776
ted == 1776
*ted == 25

So, after all that, you may also infer that while the address pointed by ted does not change the following expression will also be true:

*ted == andy

Declaring variables of type pointer

Thus, the declaration of pointers follow this form:

type * pointer_name;

int * number;
char * character;
float * greatnumber;

I emphasize that this asterisk (*) that we put when declaring a pointer means only that: that it is a pointer, and does not have to be confused with the reference operator that we have seen a bit earlier and that is also written with an asterisk (*). They are simply two different tasks represented with the same sign.

// my first pointer
#include <iostream.h>

main ()
{
  int value1 = 5, value2 = 15;
  int * mypointer;

  mypointer = &value1;
  *mypointer = 10;
  mypointer = &value2;
  *mypointer = 20;
  cout << "value1==" << value1 << "/ value2==" << value2;
  return 0;
}

For that you can see that a pointer may take several different values during the same program we have repeated the process with value2 and the same pointer.

Here is an example a bit more complicated:

// more pointers #include <iostream.h> main () { int value1 = 5, value2 = 15; int *p1, *p2; p1 = &value1; // p1 = address of value1 p2 = &value2; // p2 = address of value2 *p1 = 10; // value pointed by p1 = 10 *p2 = *p1; // value pointed by p2 = value pointed by p1 p1 = p2; // p1 = p2 (pointer assignation) *p1 = 20; // value pointed by p1 = 20 cout << "value1==" << value1 << "/ value2==" << value2; return 0; }

value1==10 / value2==20

I have included as comments on each line how the code can be read: ampersand (&) as "direction of" and asterisk (*) as "value pointed by". Notice that there are expressions with pointers p1 and p2 with and without asterisk. The meaning to put or not a reference asterisk is much different: An asterisk (*) followed by the pointer refers to the site pointed by the pointer, whereas a pointer without an asterisk (*) refers to the value of the pointer itself, that is, the address where is pointing to.

Another thing that can call your attention is the line:

int *p1, *p2;

Pointers and arrays

int numbers [20];
int * p;

p = numbers;

numbers = p;

Due to its character of variables all the expressions that include pointers in the following example are perfectly valid:

// more pointers
#include <iostream.h>

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;
}

In chapter "Arrays" we used several times barcket signs [] in order to specify the index of the element from the Array that we wanted to refer. Well, the bracket signs operator [] are known as offset operators and they are equivalent to add the number within brackets to the address of a pointer. For example, both following expressions:

a[5] = 0;       // a [offset of 5] = 0
*(a+5) = 0;     // pointed by (a+5) = 0

Pointer initialization

int number;
int *tommy = &number;

int number;
int *tommy;
tommy = &number;

int number;
int *tommy;
*tommy = &number;

Like 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 moment of declaring the variable pointer:

char * terry = "hello";

The pointer terry points to a string of characters and can be used exactly just as if it was an Array (remember that an array is just a constant pointer). For example, if our humor has changed and we want that in the content pointed by terry the 'o' be replaced by a '!' sign, we could do it by any of these two ways:

terry[4] = '!';
*(terry+4) = '!';

Arithmetic of pointers

When we saw the different data types that exist, we saw that some occupy more or less space than others in the memory. For example, integer numbers, char occupies 1 byte, short occupies 2 bytes and long occupies 4.

Let's suppose that we have 3 pointers:

char *mychar;
short *myshort;
long *mylong;

So if we write:

mychar++;
myshort++;
mylong++;

mychar = mychar + 1;
myshort = myshort + 1;
mylong = mylong + 1;

*p++;
*p++ = *q++;

*p = *q;
p++;
q++;

Pointers to pointers

char a;
char * b;
char ** c;
a = 'z';
b = &a;
c = &b;

c is a variable of type (char **) with a value of 10502
*c is a variable of type (char*) with a value of 8092
**c is a variable of type (char) with a value of'z'

void pointers

One of its utilities is for passing generic parameters to a function:

// integer increaser
#include <iostream.h>

void increase (void* data, int type)
{
  switch (type)
  {
    case sizeof(char) : (*((char*)data))++; break;
    case sizeof(short): (*((short*)data))++; break;
    case sizeof(long) : (*((long*)data))++; break;
  }
}

main ()
{
  char a = 5;
  short b = 9;
  long c = 12;
  increase (&a,sizeof(a));
  increase (&b,sizeof(b));
  increase (&c,sizeof(c));
  cout << (int) a << ", " << b << ", " << c;
  return 0;
}

Pointers to functions

// pointer to functions
#include <iostream.h>

int addition (int a, int b)
{ return (a+b); }

int subtraction (int a, int b)
{ return (a-b); }

int (*minus)(int,int) = subtraction;

int operation (int x, int y, int (*functocall)(int,int))
{
  int g;
  g = (*functocall)(x,y);
  return (g);
}

int main ()
{
  int m,n;
  m = operation (7, 5, &addition);
  n = operation (20, m, minus);
  cout <<n;
  return 0;
}

int (* minus)(int,int) = subtraction;

© The C++ Resources Network, 1999 - All rights reserved

Previous: 3-2. Strings of characters.

index

Next: 3-4. Dynamic memory.