Punteros

El concepto de puntero está unido a la forma en que los tipos de datos son almacenados en la memoria de un ordenador, ya que denotan la dirección (address) o localización de una variable determinada. El nombre de la variable determina el tipo (char, int, float o double) y su dirección determina dónde está almacenada. Conocer la dirección de una variable es importante porque:

Permite que las funciones cambien el valor de sus argumentos, como veremos en el capítulo siguiente.
Permite pasar vectores de forma eficiente entre funciones: en lugar de copiar cada elemento del vector, se copia la dirección del primer elemento.
Permite reservar memoria en tiempo de ejecución en lugar de en tiempo de compilación, lo que significa que el tamañ de un vector puede ser determinado por el usuario en lugar de por el programador.

El nombre de un array es un puntero al array. Por tanto, los punteros y los arrays están íntimamente ligados en C y en C++.

Terminología básica.

Para entender los punteros y los vectores, es necesario conocer primero cómo se almacenan los números en la memoria del ordenador. El valor de cada variable en un programa de ordenador se guarda en una sección de memoria cuyo tamaño está determinado por el tipo de dato de la variable. La localización de esta sección de memoria es almacenada en la dirección de la variable. Por tanto, es como si cada variable estuviera compuesta de dos partes: su valor y su dirección. Cada celda de memoria se puede considerar compuesta de una parte con el contenido, y otra en la que se almacena la dirección. Esto es an´alogo a una fila de casas: cada casa tiene diferentes contenidos, y para mirarla necesitamos conocer su dirección.
Las direcciones se representan normalmente por un número hexadecimal, pudiendo contener un carácter, un entero o un real (aunque en realidad todos son almacenados como números binarios).
Para obtener la dirección de una variable se utiliza el operador dirección &:

#include <iostream.h> main() { double d = 2.7183; cout << "numero = " << d << "\tdirección = " << &d << '\n'; }

El valor de d es 2.7183. El valor de &d es una dirección (donde 2.7183 está almacenado). La dirección es imprimida en formato hexadecimal.

Direcciones y punteros

Un puntero guarda la dirección de un objeto en memoria, y como tal un puntero es también una variable. Puede parecer algo confuso, es como decir que el contenido de una casa es la dirección de otra vivienda. Las direcciones se guardan como números hexadecimales, por lo que no hay ninguna razón por la que no podamos definir otro tipo de dato, similar a un entero, pero a través del cual se puede modificar el valor almacenado en esa dirección. Es importante entender la relación entre punteros y direcciones>

Cada variable tiene su dirección, que puede ser obtenida mediante el operador unario &.
La dirección de una variable puede ser almacenada en un tipo de dato llamado puntero.

Un puntero en C o en C++ se declara anteponiendo un * al nombre de la variable, que es el operador inverso a &. El puntero apunta entonces a una variable del tipo especificado, y no debe ser usado con variables de otros tipos. Un experto en C podría forzar la utilización de un puntero con un tipo distinto del que se ha declarado, pero no es recomendable, ya que podría conducir a un uso erróneo.

Veamos algunos ejemplos de declaración de punteros:

int *puntero1; int *puntero2, *puntero3; char variable, *punteroCaracter; float *punteroReal, real;

En la primera línea, declaramos un puntero a un entero. En la segunda, dos punteros a entero. En la tercera, un carácter ( variable) y un puntero a carácter (punteroCaracter). Por último, punteroReal) es un puntero a un real, y real es declarado como un número real.

Veamos un ejemplo de uso del operador * y del operador de dirección (&):

#include <iostream.h> main() double d, *dp; d = 2.7183; *dp = &d; cout << "numero = " << d << "\tdirección = " << &d << '\n';

Veamos un programa completo:

# include <iostream.h>

main () { int *ptInt; int var1 = 7, var2 = 27;

ptInt = &var1; var2 = *ptInt;

cout << " var1 = " << var1 << " var2 = " <<var2 << "*ptInt = " <<*ptInt << '\n';

*ptInt = 5;

cout << " var1 = " << var1 << " var2 = " <<var2 << "*ptInt = " <<*ptInt << '\n';

ptInt = &*ptInt; var1 = *&var1; }

El resultado de la ejecución es:

var1 =7 var2 = 7 *ptInt = 7 var1 = 5 var2 =7 *ptInt = 5

Estudiemos el funcionamiento del programa:

Se asigna a ptInt la dirección de var1. Entonces el valor de ptInt es la dirección de memoria de var1.
A var2 se asigna el valor al que ptInt apunta. Entonces el valor de var2 es el contenido de la localización de memoria la que ptInt apunta (var1).
Después de imprimir los tres valores por primera vez, el contenido de la direcció a la que apunta ptInt es cambiado a 5. Como este contenido es var1, el valor de var1 es ahora 5, pero var2 no es modificado.
Las dos últimas líneas ilustran cómo los operadores * y & son conceptos inversos. Nótese que el orden de precedencia es de izquierda a derecha, por tanto el más cercano a la variable es siempre el primero que se aplica.

Otro ejemplo:

#include <iostream.h>

main() { int i = 2; int *ip = &i; int **ipp = &ip; int ***ippp = &ipp;

cout << " i = " << i << endl << " *ip = " << *ip << endl << " *ipp = " << *ipp << endl << " *ippp = " << *ippp << endl

<< " &i = " << &i << endl << " ip = " << ip << endl << " ipp = " << ipp << endl << " ippp = " << ippp << endl; } La salida de este programa es:

i = 2 *ip = 2 *ipp = 0x11ffff908 *ippp = 0x11ffff900 &i = 0x11ffff908 ip = 0x11ffff908 ipp = 0x11ffff900 ippp = 0x11ffff8f8

Operaciones con punteros

Un puntero es un tipo de dato similar a un entero, y hay un conjunto de operaciones definidas para punteros:

La suma o resta de un entero produce una nueva localización de memoria.
Se pueden comparar punteros, utilizando expresiones lógicas, para ver si están apuntando o no a la misma dirección de memoria.
La resta de dos punteros da como resultado el número de variables entre las dos direcciones.

Veamos un ejemplo de utilización de punteros:


#include <iostream.h>
main()

{

  int vector[3];

  int princPunt = vector;

  int finPunt = &vector;

  vector[2] = 15;

  cout << *(princPunt+2) << *finPunt <<'\n';


  if (princPunt == finPunt)

    cout  << " Esto no puede suceder "  << '\n';


  cout  << "Numero de elementos"  <<finPunt-princPunt << 
'\n';
 
}

Veamos cómo trabaja este programa:

princPunt es la dirección del primer elemento de vector, y finPunt la dirección del último elemento. int princPunt = vector; es una combinación de declaració y definición.
La expresión *(princPunt+2) incrementa el valor del puntero princPunt en dos y devuelve el número guardado en esa localización, es decir, apunta a la tercera localización de memoria y su valor es 15.
Se pueden utilizar también enteros en formato hexadecimal. Así,
cout << *(princPunt + 17 )
y
cout << *(princPunt + 0x11 )
producen la misma salida.
La expresión princPunt == finPunt comprueba si los dos punteros son iguales. Esto sólo puede ser verdad si los dos punteros apuntan a la misma variable.

Siempre que se realiza una operación aritmética sobre un puntero, sumando o restando un entero, el puntero se incrementa o decrementa un número apropiado de sitios tal que el nuevo valor apunta a la variable que está n elementos (no n bytes) antes o después que el dado. De la misma forma, al restar dos punteros se obtiene el número de objetos entre las dos localizaciones. Finalmente, dos punteros son iguales si y sólo si apuntan a la misma variable (el valor de las direcciones es el mismo). No son necesariamente iguales si sus valores indirectos son los mismos, ya que estas variables podrín estar en diferentes localizaciones de memoria.

Punteros constantes y punteros a constantes.

C++ permite definir un puntero a una constante, de forma que el valor al que el puntero apunta no pueda ser cambiado, pero el puntero en si puede cambiar para apuntar a otra variable o constante:

char const *p;

p es un puntero a un carácter, declarado como constante. El carácter al que apunta p no debe ser cambiado. El puntero p en si puede modificarse. Así, *p = 'a' no es válido, pero p++ si lo es.

Además, se puede declarar un puntero constante, que no puede ser cambiado:

En la declaración:

char *cont p;

p es un puntero constante que no puede ser cambiado. El carácter al que apunta sin embargo sí puede modificarse.

Por último :

char const *const p;

indica que ni el puntero p ni el carácter al que apunta pueden ser modificados.

Estas construcciones pueden utilizarse para mejorar la calidad del código. Si un puntero o una variable no serán nunca cambiados deben declararse como constantes. El compilador indicará si inadvertidamente se han modificado estos valores.

Puntero a void.

El puntero a void es también un elemento del ANSI-C. A un puntero a void puede asignarse el valor de cualquier puntero de otro tipo. Por ejemplo, en el siguiente programa, al puntero general se le asigna primero la dirección de un entero, y después la de un número real:

#include <iostream.h>

main () { int *ptInt; float *ptFloat; int var1 = 7, var2 = 27; float x = 1.2345, y = 32.14; void *general;

ptInt = &var1; *ptInt + = var2; cout << " var1 tiene ahora el valor" << *ptInt << '\n'; general = ptInt;

ptFloat = &x; y + =5 * (*ptFloat); cout << " y tiene ahora el valor" << y << '\n'; general = ptFloat;

}

Esto permite al programador definir un puntero que puede ser usado para apuntar a variables de tipos diferentes para transferir información a lo largo del programa. Un buen ejemplo es la función malloc(), que devuelve un puntero a void. Este puntero puede ser asignado a un puntero de cualquier tipo, transfiriendo el puntero devuelto al tipo correcto.
Un puntero a void se almacena en memoria de forma que puede ser utilizado con cualquiera de los tipos simples predefinidos en C++, pero también pueden ser utilizados con los tipos compuestos que el usuario define, puesto que los tipos compuestos están formados por tipos simples.

Reserva dinámica de memoria

Los operadores new y delete se utilizan para reservar y liberar memoria dinámicamente, de forma similar a las funciones malloc() y free() en C. Ahora los operadores new y delete son parte del lenguaje C++ y no parte de una librería. El propósito de new es crear arrays cuyo tamaño pueda ser determinado mientras el programa corre.
Delete funciona igual que free en C. El contenido al que apunta el puntero es borrado, pero no el puntero en sí. Se pueden crear más variables y hacer que el localización sea el mismo puntero.
Veamos un ejemplo de utilización de estos operadores


# include <iostream.h>
main()

{

  int index, *point1, *point2;


  point1 = &index;

  *point1 = 77;

  point2 = new int;

  *point2 = 173;

  cout <<"Los valores son "
<< index <<" " << *point1 << " "<<
*point2 <<'\n';


  point1 = new int;

  point2 = point1;

  *point1 = 999;

  cout <<"Los valores son "
<< index <<" " << *point1 << " "<<
  *point2 <<'\n';


  delete point1;


  float *float_point1, *float_point2 = new float;

  float _point1 = new float;

  *float_point2 = 3.14159;

  *float_point1 = 2.4 * (*float_point2);

  delete float_point2;

  delete float_point1;


  char *c_point;

  c_point = new date;

  delete c_point;
  c_point = new char [sizeof(int) + 133];

  delete c_point;

}

Resultado de la ejecución:

Los valores son 77 77 173 Los valores son 77 999 999

En las primeras líneas del programa, se hace uso de los punteros tal y como se hacía en C.
point2 ilustra el uso del operador new. Este operador requiere un modificador que debe ser un tipo. La parte new int significa que se crea un nuevo entero en la memoria, y devuelve la localización del entero creado. Esta localización es asignada a point2. La siguiente línea asigna 173 al entero al que apunta point2. Es importante distinguir entre point2, la localización del entero, y *point2, el entero. El puntero point2 apunta ahora a una variable entera que se ha reservado dinámicamente, y que puede utilizarse de igual forma que se hacía en C. Como ejemplo, se imprime el valor al que apunta.
A continuación, se reserva memoria para una nueva variable, y point2 se refiere a la misma variable reservada dinámicamente a la que apunta point1. En este caso, la referencia a la variable a la que point2 apuntaba previamente se ha perdido, y nunca podrá ser utilizada o su memoria liberada. Sólo cuando se vuelva al sistema operativo se liberará la memoria que ocupaba. Por tanto, no debe utilizarse.
Ya que el puntero point1 en sí no ha cambiado, apunta realmente al dato original. Este dato podría referenciarse otra vez utilizando point1, pero no es una buena práctica de programación, ya que no hay garantía de lo que el sistema pueda hacer con el puntero o el dato. La localización del dato queda libre para ser reservada en una llamada subsiguiente, y será pronto reutilizada en cualquier programa.
Ya que el operador delete está definido para no hacer nada si se le pasa un valor NULL, se puede liberar la memoria ocupada por un dato al que apunta un puntero NULL, ya que realmente no se está haciendo nada. El operador delete sólo puede utilizarse para liberar memoria reservada con el operador new. Si se usa delete con cualquier otro tipo de dato, la operación no está definida, y por tanto nada sucede.
En el programa también declaramos algunas variables reales, y se realizan operaciones similares a las anteriores. De nuevo esto ilustra que en C++ las variables no tienen que ser declaradas al comienzo de cada bloque. Una declaración es una sentencia ejecutable y puede entonces aparecer en cualquier lugar en la lista de sentencias ejecutables.
Finalmente, ya que el operador new requiere un tipo para determinar el tamaño de un bloque dinámicamente reservado, se muestra cómo reservar un bloque de tamaño arbitrario. Esto es posible utilizando la construccíon de las últimas líneas de programa, donde un bloque de 37 caracteres de tamaño (37 bytes) es reservado. Un bloque de 133 bytes mayor que el tamaño de un entero se reserva posteriormente. Por tanto, el operador new se puede utilizar con la misma flexibilidad de la función malloc () de C.
Cuando los datos reservados dinámicamente son borrados con delete, todavía quedan en memoria. Si repetimos la instrucción cout inmediatamente después de utilizar delete, veremos que todavía se conservan los valores. Si la repetimos de nuevo antes de dejar el programa, cuando el espacio que ocupaban debe haber sido sobreescrito, veremos que ya no es así. Incluso aunque el compilador nos de los números correctos, no es una buena práctica pensar que esos datos están ahí todavía, porque en un programa dinámico largo la memoria se usará continuadamente.
Las funciones estándar utilizadas en C para manejo dinámico de memoria, malloc(), calloc() y free(), también se pueden utilizar en C++ de la misma forma que en C. Los operadores new y delete no deben mezclarse con estas funciones, ya que los resultados pueden ser impredecibles. Si se está partiendo de código C, lo mejor es continuar utilizando las funciones en las nuevas líneas de programa. Si no es así, se deben utilizar los nuevos operadores, ya que se han construido como parte del lenguaje en sí, más que añadirse, y por tanto son más eficientes.
Cuando se utiliza new para reservar memoria para un vector, el tamañ del vector se sitúa entre corchetes, siguiendo al tipo:
int *intvector; intvector = new int [20];
y se libera:
delete [] intvector;

Punteros a funciones Punteros a funciones

Los punteros a funciones ya existían en C, aunque no se utilizan regularmente. Veamos un ejemplo:

#include <iostream.h>

void printMensaje (float dato); void printNumero (float dato); void (*funcPuntero)(float);

main() { float pi = 3.14159; printMensaje(pi); funcPuntero = printMensaje; funcPuntero (pi); funcPuntero = printNumero; funcPuntero (pi); printNumero(pi); }

void printMensaje(float dato) { cout <<" Esta es la funcion printMensaje " <<'\n'; }

void printNumero(float dato) { cout <<" Este es el dato: " << dato << '\n'; }

La salida del programa será:

Esta es la funcion printMensaje Esta es la funcion printMensaje Este es el dato: 3.14159 Este es el dato: 3.14159

Hemos declarado dos funciones, printMensaje y printNumero, y después funcPuntero, que es un puntero a una función que recibe un parámetro real y no devuelve nada (void). Las dos funciones declaradas anteriormente se ajustan precisamente a este perfil, y por tanto pueden ser llamadas por este puntero.
En la función principal, llamamos a la función printMensaje con el parámetro pi, y en la línea siguiente asignamos al puntero a función funcPuntero el valor de printMensaje y utilizamos el puntero para llamar a la misma función de nuevo. Por tanto, las dos llamadas a la función printMensaje son idénticas gracias a la utilización del puntero funcPuntero.

Dado que hemos asignado el nombre de una función a un puntero a función, y el compilador no da error, el nombre de una función debe ser un puntero a una función. Esto es exactamente lo que sucede. Un nombre de una función es un puntero a esa función, pero es un puntero constante que no puede ser cambiado. Sucede lo mismo con los vectores: el nombre de un vector es un puntero constante al primer elemento del vector.
Ya que el nombre de una función es un puntero a esa función, podemos asignar el nombre de una función a un puntero constante, y usar el puntero para llamar a la función. Pero el valor devuelto, así como el número y tipo de parámetros deben ser idénticos. Muchos compiladores de C y C++ no avisan de las diferencias entre las listas de parámetros cuando se hacen las asignaciones. Esto se debe a que las asignaciones se hacen en tiempo de ejecución, cuando la información de este tipo no está disponible para el sistema.
Si en el ejemplo anterior añadimos una función que tiene como parámetro un entero e intentamos llamarla con el puntero a función funcPuntero, el compilador lanzará el siguiente mensaje de error:

error: In this statement, the referenced type of the pointer value "print_int" is "function (int) returning void", which is not compatible with "function (float) returning void". Compilation terminated with errors.