Czyszczenie listy/wektora wskaźników STL

Question

Jaka jest najkrótsza partia C++, którą możesz wymyślić, aby bezpiecznie wyczyścić wektor lub listę wskaźników? (zakładając, że musisz wywołać delete na wskaźnikach?)

list<Foo*> foo_list; 

Wolałbym nie używać Boost ani nie owijać moich wskaźników inteligentnymi wskaźnikami.

Answer 1

Ponieważ rzucają rękawicę tutaj ... „najkrótsza fragmencie C++”

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

foo_list . remove_if (deleteAll); 

myślę, że możemy zaufać ludzi, którzy przyszli z STL mieć efektywnych algorytmów. Po co wyważać koło?

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

nie jestem pewien, że podejście funktor wygrywa dla zwięzłości tutaj.

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

Zazwyczaj jednak odradzam. Zawijanie wskaźników w inteligentne wskaźniki lub używanie specjalistycznego pojemnika wskaźnikowego jest na ogół bardziej niezawodne. Istnieje wiele sposobów, które można usunąć z listy (różne smaki: erase, clear, niszczenie listy, przypisywanie za pomocą iteratora do listy itp.). Czy możesz zagwarantować, że złapiesz je wszystkie?

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

Dla std::list<T*> użytku:

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

Dla std::vector<T*> użytku:

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

Nie wiem, dlaczego wziąłem front zamiast back dla std::list powyżej. Sądzę, że to uczucie, że jest szybciej. Ale w rzeczywistości obie są stałym czasem :). W każdym razie zapakuj go do funkcji i baw się dobrze:

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

Answer 7

To naprawdę niebezpieczne, polegać na kodzie poza kontenerem, aby usunąć wskaźniki. Co dzieje się, gdy kontener zostanie zniszczony na przykład przez zgłoszony wyjątek?

Wiem, że powiedziałeś, że nie lubisz wzmocnienia, ale rozważ proszę boost pointer containers.

Answer 8

Przynajmniej dla listy, iteracji i usuwania, to wywoływanie wyczyść na końcu jest trochę niewygodne, ponieważ obejmuje dwukrotne przechodzenie przez listę, kiedy naprawdę trzeba zrobić to tylko raz. Tutaj jest trochę lepszy sposób:

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); 
} 

Powiedział, że kompilator może być wystarczająco inteligentny pętli połączyć dwa tak czy inaczej, w zależności od tego, jak lista :: jasne jest realizowany.

Answer 9

Faktycznie, uważam, że biblioteka STD zapewnia bezpośredni sposób zarządzania pamięcią w formie allocator class

można rozszerzyć metodę automatycznie usuwać członków dowolnego kontenera na podstawowy podzielnika Deallocate().

Ja/myśl/jest to typ rzeczy, do której jest przeznaczony.

Answer 10

Następujący hack usuwa wskaźniki, gdy twoja lista wykracza poza zasięg używając RAII lub jeśli wywołasz 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_; 
}; 

Przykład:

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

Jeśli pozwolisz C++ 11, można zrobić bardzo krótką wersję odpowiedzi Douglas Leeder za:

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(); 

tam mały powód, dla którego nie chcesz tego robić - skutecznie przechodzisz na drugą stronę listę dwa razy.

std :: lista <> :: jasne jest liniowe w złożoności; usuwa i niszczy jeden element na raz w pętli.

Biorąc powyższe pod uwagę najprostszą czytać rozwiązanie moim zdaniem jest:

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

Answer 14

Ponieważ C++ 11:

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

Lub, jeśli piszesz kod szablonie i chcą uniknąć określając rodzaj betonu:

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

Które (od C++ 14) może zostać skrócony, jak:

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