UC3M

Los punteros tienen dos cometidos. El primero es almacenar una dirección de memoria (ver sección 5.4). El segundo es utilizar la dirección de memoria almacenada para acceder al dato al que apunta mediante una indirección (ver sección 5.2 es una indirección).

En C la indirección se denota con el operador * seguido del nombre de una variable de tipo puntero. Su significado es “accede al contenido al que apunta el puntero”. Desafortunadamente, este operador coincide con el utilizado para denotar los tipos de datos punteros y para declarar este tipo de variables. Es muy importante tener una distinción muy clara entre estos dos usos del operador. Al traducir un programa, el compilador no comprueba ni que el puntero contiene una dirección de memoria correcta, ni que en esa dirección de memoria hay un dato correcto. Esta característica hace que el diseño de programas con punteros sea complejo.

El siguiente programa muestra el uso del operador de indirección (fichero pointer_example_2.c):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>
int main(int argc, char** argv) 
{
    int num1, num2;
    int *ptr1, *ptr2;

    ptr1 = &num1;
    ptr2 = &num2;

    num1 = 10;
    num2 = 20;

    *ptr1 = 30;
    *ptr2 = 40;

    *ptr2 = *ptr1;

    return 0;
}

La línea 13 asigna el valor 30 a la dirección de memoria almacenada en ptr1 mediante una indirección. Como el puntero tiene la dirección de num1 (asignada en la línea 7) esta linea es análoga a asignar el valor 30 directamente a num1. Análogamente, la línea 14 asigna el valor 40 a la dirección a la que apunta ptr2. Esta asignación es equivalente a asignar el valor 40 a num2. La línea 16 contiene dos indirecciones. La expresión a la derecha del signo igual obtiene el dato en la posición indicada por la dirección almacenada en ptr1 (la dirección de num1) y este dato se almacena en la posición indicada por el puntero ptr2 (la dirección de num2). Al terminar el programa, la variable num2 contiene el valor 30 a pesar de que no ha sido asignado directamente.

La siguiente figura muestra la evolución de estas cuatro variables a lo largo del programa. De nuevo, las direcciones de memoria en las que están almacenadas son arbitrarias.

La coincidencia entre el operador de indirección y el de definición de tipo puntero “*” puede dificultar la comprensión del código. Por ejemplo, la siguiente línea

int *r = *p;

contiene dos operandos “*”. El primero se define el tipo “puntero a entero” y va seguido de la declaración de la variable “r”. El segundo es una indirección que se aplica a la dirección almacenada en el puntero “p”.

1
2
3
4
5
6
7
8
9
10

struct s 
{
    int x;
    char c;
}

struct s element;
struct s *pointer;

pointer = &element;

(*pointer).x = 10;
(*pointer).c = 'l';

pointer->x = 10;
pointer->c = 'l';

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/* Definición de la estructura */
struct coordenadas 
{
    float x;
    float y;
    float z;
};

int main() 
{
    /* Declaración de dos estructuras */
    struct coordenadas location1, location2;
    /* Declaración de dos punteros */
    struct coordenadas *ptr1, *ptr2;

    /* Asignación de direcciones a los punteros */
    ptr1 = &location1;
    ptr2 = &location2;

    /* Asignación de valores a la primera estructura */
    ptr1->x = 3.5;
    ptr1->y = 5.5;
    ptr1->z = 10.5;

    /* Copia de valores a la segunda estructura */
    ptr2->x = ptr1->x;
    ptr2->y = ptr1->y;
    ptr2->z = ptr1->z;
  
    return 0;
}