Reserva dinámica de memoria

# 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 char;
  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 del 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 dé 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;

[Índice][Previo] [Siguiente]

Comentarios, sugerencias, ideas...

© Beatriz Fuentes Arenaz, 1996-1997