[SOLUCIONADO] Duda con punteros

[Andrek]

Hola amigos!

Tengo una duda y es que si quiero asignar memoria a un puntero debo liberar la memoria que ya tiene almacenada de manera dinamica?

Ejemplo:

Código:

class X
{
public:
    int n;
};

int main(int argc, char* args[])
{
    X *p;
    p = new X;
    delete p; // Es necesario?
    p = new X;
    delete p;
    return 0;
}

Intente quitando el primer 'delete p' y no se como ver si el resultado es que tengo ahora 2 clases X.

Gracias por leer!

[xKuZz]

Un puntero apunta a una única dirección de memoria, en tu caso con el primer new has reservado espacio para una clase X y la has creado con el constructor por defecto, has liberado ese espacio, nas vuelto a reservar y crear la clase X con el constructor por defecto y has vuelto a liberar ese espacio. El delete es necesario para que no se produzca una fuga de memoria en ese caso.

Para conseguir lo que tu quieres has de utilizar la variación de new/ delete con []

Código C++:

int main(int argc, char* args[])
{
    X *p;
    p = new X[2]; // Cogemos y creamos dos clases X memorias en contigua
    p[0].n = 3;   // p[0] == *p es la primera clase X
    p[1].n = 4;   // p[1] == *(p + 1) es la segunda clase X que hemos creado
    delete[] p;   // Para realizar delete utilizamos la variación con []
    return 0;
}
 

[Andrek]

Gracias por contestar amigo!

Pero eso no resuelve mi duda, yo necesito crear clases aleatorias cada cierto tiempo, por eso estoy preguntando si al usar el operador 'new' el vacia automaticamente el puntero o solo devuelve una direccion y mi puntero solo cambia de direccion y no libera la memoria que esta usando.

Ejemplo:

Código:

char option;
p = new X;
do {
cout << X << endl;
cout << "Te gusta esta clase?" << endl;
cin >> option;
} while(option != 'y');
if(option == 'y') {
hacer algo.....
} else {
delete p;
}

Quisiera saber si hay una forma diferente de hacer eso, ya que si me equivoco y libero la memoria 2 veces da error :S

Gracias!!

[xKuZz]

No vacía el espacio asignado, debes de vaciarlo explícitamente con delete, antes de volver a llamar a new. No obstante, esa metodología a mi punto de vista parece incorrecta por dos razones:

• Es posible que el compilador optimice el uso de new después de delete y te quedes todo el rato con la misma posición de memoria
• En caso contrario, estás malgastando tiempo en liberar y reservar memoria y la aleatoriedad de los datos en realidad son datos que fueron usados por otras aplicaciones y procesos del sistema previamente.

Sería, en mi opinión, más correcto realizar lo siguiente:

• En el constructor por defecto asignar un valor aleatorio a la variable de instancia n. [I]Si no sabes hacerlo basta buscar en Google "numeros aleatorios c++" (o si lo prefieres y puedes la nueva forma de hacerlo de c++11)
• En vez de realizar delete llamar al constructor por defecto de nuevo de la siguiente manera:
  
  
  Código C++:

  class X
  {
  public:
      int n;
    X() {
      // Implementación aleatorio
    }
  };
   
  int main(int argc, char* args[])
  {
      X *p;
      p = new X;
      // Hacer algo
      *p = X(); // Ahora se asignaría un nuevo valor aleatorio a la instancia p de la clase X
      delete p; // Sólo es necesario un delete al final
      return 0;
  }
   

[Andrek]

Wow eso ultimo es lo que necesitaba saber, un metodo diferente y que me parece logico, ya que como lo estaba haciendo funciona pero sentia que no era correcto, por eso pregunte!, GRACIAS HOMBRE!

Si se usar los numero aleatorios, tengo 1 semana con c++ pero siempre habia leido mucho y se mucha teoria pero poca practica, yo programo en Ruby y como entenderas estaba muy acostumbrado a lo automatico, pero me fascina c++ por su precision.

Cambiar el contenido del puntero eso es lo mas correcto, gracias!.

[eferion]

Iniciado por xKuZz

No obstante, esa metodología a mi punto de vista parece incorrecta por dos razones:

Yo iría un poco más lejos aún.

Si no es estrictamente necesario bien por requisitos de la práctica (vamos, que te exijan hacerlo así), bien por necesidades propias de la aplicación (uso de polimorfismo, variable compartida, ...) yo te recomendaría evitar el uso de punteros en la medida de lo posible.

Evitas fugas de memoria, el programa será más rápido (las reservas de memoria son relativamente lentas), aprovecharás el principio de localidad para mejorar los tiempos de acceso a datos y el programa quedará algo más limpio:

Código C++:

int main(int argc, char* args[])
{
    X p;
    // ...
 
    p = X(); // Ahora se asignaría un nuevo valor aleatorio a la instancia p de la clase X
    // ...
 
    return 0;
}
 

En caso de ser necesario el uso de punteros yo te sugeriría usar los punteros inteligentes. En el caso de un puntero que no vas a compartir lo ideal sería unique_ptr:

Código C++:

#include <memory>
 
int main(int argc, char* args[])
{
    std::unique_ptr<X> p(new X());
    // ...
 
    p.reset(new X()); // esta instrucción equivale a delete + new
    // ...
 
    // no hace falta hacer delete
    return 0;
}
 

Los punteros inteligentes no alteran la forma de acceder al objeto (se sigue usando el operador '->') y ellos solos se encargan de llamar al delete correspondiente cuando proceda:

Código C++:

struct POO
{
  POO()
  { var = 1; std::cout << "POO()" << std::endl; }
 
  ~POO()
  { std::cout << "~POO()" << std::endl; }
 
  int var;
}
 
int func()
{
  std::unique_ptr<POO> ptr(new POO);
  std::cout << ptr->var << std::endl;
  // nota que aparecerá el mensaje del destructor pese a no existir ningún delete
}
 
int main()
{
  for( int i=0; i<5; i++ )
    func();
}
 

Un saludo.