Uf.... veamos:
Los objetos que tu llamas estáticos se destruyen automáticamente cuando salen de ámbito (go out of scope). Es decir:
{
Tarari c;
...
} // aquí se destruye automáticamente c
Si haces new, siempre tienes que hacer un delete. De modo que si tienes un vector<T *> *, para destruirlo correctamente debes:
- Hacer delete de los punteros que hayas almacenado en el vector
- Después, hacer delete del vector
Cuando haces delete de un objeto EVIDENTEMENTE se ejecuta su destructor.
¿Es óptimo pasar el destructor constantemente para liberar memoria? ¿No es mejor pasarlo en función de las necesidades de reutilización de la memoria?
Esto no lo entendí, pero me da la sensación de que la respuesta es "Estás muy confundido".
Y una vez dicho esto.... lo que tienes que hacer es NO USAR PUNTEROS (a no ser que sepas lo que estás haciendo, y evidentemente no lo sabes porque las dudas son básicas). Lo que tienes que usar es el template std::tr1::shared_ptr que está en cualquier compilador medio decente. Esta clase se encarga de llamar a delete cuando ya no se necesita el puntero. Así de fácil de usar:
#include <iostream>
#include <tr1/memory>
struct A
{
A() { std::cout << "ctor" << std::endl; }
~A() { std::cout << "dtor" << std::endl; }
void test() const { std::cout << "test" << std::endl; }
};
void f1(const std::tr1::shared_ptr<A> a)
{
a->test();
}
void f2(const A * const a)
{
a->test();
}
int main(int argc, char *argv[])
{
int i(0);
std::cout << i++ << std::endl;
std::tr1::shared_ptr<A> a(new A);
std::cout << i++ << std::endl;
{
std::cout << i++ << std::endl;
std::tr1::shared_ptr<A> aa(a);
std::cout << i++ << std::endl;
f1(aa);
std::cout << i++ << std::endl;
}
std::cout << i++ << std::endl;
f2(a.get());
std::cout << i++ << std::endl;
return 0;
}
Como se puede ver en el ejemplo solo se ejecuta un constructor y un destructor (dado que solo creamos un objeto). Además es 'transparente' en cuanto a que podemos seguir usándolo como un puntero (*, ->, ...)
Saludos.
-------
Es más, como muestra vale un botón. El caso de crear un vector con varios punteros y liberarlos:
std::vector<A *> * v(new std::vector<A *>);
v->push_back(new A);
v->push_back(new A);
v->push_back(new A);
v->push_back(new A);
v->push_back(new A);
// ... usar v y los 'A' que hemos creado
for (std::vector<A *>::iterator i(v->begin()), i_end(v->end()) ; i != i_end ; ++i)
delete *i;
delete v;
Es decir, comparado con lo siguiente, un puñetero engorro:
std::vector<std::tr1::shared_ptr<A> > v(new std::vector<std::tr1::shared_ptr<A> >);
v->push_back(new A);
v->push_back(new A);
v->push_back(new A);
v->push_back(new A);
// ... usar normalmente v y los 'A' creados
// Ops... se destruye todo automáticamente
Saludos.
![[enfado1]](/images/smilies/nuevos/enfado_ani1.gif "enfadado")
Llevo años sin programar en C++, así que estoy muy desconectado del lenguaje. Por lo que entiendo cuando usas la orden delete sobre un objeto, este se libera de memoria. La pregunta es si es mas óptimo liberar memoria cada vez que se usa una "orden delete", o por el contrario es mas óptimo que cuando se usa una "orden delete" se apunte el objeto como destruible y cuando se necesite memoria se liberen todos los objetos de la lista, como hace por ejemplo el recolector de basura de Java, que pasa cuando le parece y no cuando lo llamas. 