Limpiar una lista/vector de punteros AWL

Question

¿Cuál es el trozo más corto de C++ que se puede encontrar para limpiar de forma segura un vector o una lista de punteros? (Suponiendo que tiene para llamar a borrar de los punteros?)

list<Foo*> foo_list; 

prefiero no usar Boost o envolver mis punteros con punteros inteligentes.

Answer 1

Dado que estamos lanzando el guante aquí ... "trozo más corto de C++"

static bool deleteAll(Foo * theElement) { delete theElement; return true; } 

foo_list . remove_if (deleteAll); 

creo que podemos confiar en la gente que se acercó con STL tener algoritmos eficientes. ¿Por qué reinventar la rueda?

Answer 2

template< typename T > 
struct delete_ptr : public std::unary_function<T,bool> 
{ 
    bool operator()(T*pT) const { delete pT; return true; } 
}; 

std::for_each(foo_list.begin(), foo_list.end(), delete_ptr<Foo>()); 

Answer 3

for(list<Foo*>::const_iterator it = foo_list.begin(); it != foo_list.end(); ++it) 
{ 
    delete *it; 
} 
foo_list.clear(); 

Answer 4

no estoy seguro de que el enfoque funtor gana aquí por razones de brevedad.

for(list<Foo*>::iterator i = foo_list.begin(); i != foo_list.end(); ++i) 
    delete *i; 

Sin embargo, siempre desaconsejaré esto. Envolver los punteros en punteros inteligentes o usar un contenedor de puntero especializado es, en general, más robusto. Hay muchas formas en que los elementos se pueden eliminar de una lista (varios sabores de erase, clear, destrucción de la lista, asignación a través de un iterador en la lista, etc.). ¿Puedes garantizar atraparlos a todos?

Answer 5

for (list<Foo*>::const_iterator i = foo_list.begin(), e = foo_list.end(); i != e; ++i) 
    delete *i; 
foo_list.clear(); 

Answer 6

Para std::list<T*> uso:

while(!foo.empty()) delete foo.front(), foo.pop_front(); 

Para std::vector<T*> uso:

while(!bar.empty()) delete bar.back(), bar.pop_back(); 

No sé por qué me tomó front en lugar de back para std::list anteriormente. Supongo que es la sensación de que es más rápido. Pero en realidad ambos son tiempo constante :). De todos modos se envuelve en una función y divertirse:

template<typename Container> 
void delete_them(Container& c) { while(!c.empty()) delete c.back(), c.pop_back(); } 

Answer 7

Es muy peligroso confiar en el código fuera del recipiente para eliminar los punteros. ¿Qué sucede cuando el contenedor se destruye debido a una excepción lanzada, por ejemplo?

Sé que dijiste que no te gusta impulsar, pero ten en cuenta el boost pointer containers.

Answer 8

Al menos para una lista, iterar y eliminar, y luego llamar al final es un poco ineficiente ya que implica recorrer la lista dos veces, cuando en realidad solo tiene que hacerlo una vez. Aquí está un poco mejor manera:

for (list<Foo*>::iterator i = foo_list.begin(), e = foo_list.end(); i != e;) 
{ 
    list<Foo*>::iterator tmp(i++); 
    delete *tmp; 
    foo_list.erase(tmp); 
} 

Dicho esto, el compilador puede ser lo suficientemente inteligente como para bucle de combinar los dos modos, dependiendo de la forma en la lista :: claro está implementado.

Answer 9

En realidad, creo que la biblioteca STD proporciona un método directo de la gestión de la memoria en la forma de la allocator class

Se puede extender el método del asignador básica deallocate() para eliminar automáticamente los miembros de cualquier contenedor.

I/think/este es el tipo de cosas para las que está destinado.

Answer 10

El siguiente hack elimina los punteros cuando su lista se sale del alcance usando RAII o si llama a list :: clear().

template <typename T> 
class Deleter { 
public: 
    Deleter(T* pointer) : pointer_(pointer) { } 
    Deleter(const Deleter& deleter) { 
    Deleter* d = const_cast<Deleter*>(&deleter); 
    pointer_ = d->pointer_; 
    d->pointer_ = 0; 
    } 
    ~Deleter() { delete pointer_; } 
    T* pointer_; 
}; 

Ejemplo:

std::list<Deleter<Foo> > foo_list; 
foo_list.push_back(new Foo()); 
foo_list.clear(); 

Answer 11

void remove(Foo* foo) { delete foo; } 
.... 
for_each(foo_list.begin(), foo_list.end(), remove); 

Answer 12

Si permite que C++ 11, se puede hacer una versión muy corta de la respuesta de Douglas Leeder:

for(auto &it:foo_list) delete it; foo_list.clear(); 

Answer 13

for(list<Foo*>::const_iterator it = foo_list.begin(); it != foo_list.end(); it++) 
{ 
    delete *it; 
} 
foo_list.clear(); 

Hay una pequeña razón por la cual no querrías hacer esto - estás iterando efectivamente la lista dos veces

std :: list <> :: clear es lineal en complejidad; elimina y destruye un elemento a la vez dentro de un bucle.

Tomando en consideración lo anterior el más sencillo de leer solución en mi opinión es:

while(!foo_list.empty()) 
{ 
    delete foo_list.front(); 
    foo_list.pop_front(); 
} 

Answer 14

Como C++ 11:

std::vector<Type*> v; 
... 
std::for_each(v.begin(), v.end(), std::default_delete<Type>()); 

O, si usted está escribiendo código de plantilla y desea evitar especificar un tipo concreto:

std::for_each(v.begin(), v.end(), 
    std::default_delete<std::remove_pointer<decltype(v)::value_type>::type>()); 

Qué (desde C++ 14) se puede acortar como:

std::for_each(v.begin(), v.end(), 
    std::default_delete<std::remove_pointer_t<decltype(v)::value_type>>());