wycieki pamięci podczas dealokacji wektora wskaźników

Question

Witam,

Mam problem z dealokacją wskaźnika na wektor wskaźników, który jest polem pewnej klasy.

Według StackOverflow wystarczy w pętli dla każdego elementu takiego wektora użyć delete, a na końcu użyć metody clear(). Na cppreference (link: https://en.cppreference.com/w/cpp/container/vector/clear) jest napisane, że wszelkie wskaźniki zostaną uniważnione i nie wiem czy to oznacza, że pamięć zostaje zwolniona, czy tylko stracę adresy na zaalokowane miejsca na stercie?

Wreszcie valgrind i debugger z visuala2017 wykrywają wycieki mimo zastosowania wszystkich sensownych (według mnie) kombinacji usuwania tego wektora.

Tym krótkim przykładem pokażę na czym polega problem.

class Element {
public:
    Element(int num) { val = new int[num]; }

    ~Element() { delete[] val; }
    
private:
    int *val;
};

class Base {
public:
    Base(int size) { 
        list = new std::vector<Element*>(size, new Element(1000)); 
    }

    ~Base() { 
        /* odkomentowanie spowoduje podwojne zwolnienie pamieci 
         * mimo ze teoretycznie teraz sa wycieki
         
        for(int i = 0; i < list->size(); ++i) {
            delete list->at(i);
        }
        */
        list->clear();
        delete list;
    }


private:
    std::vector<Element*> *list;
};

Teraz dla przykładowej instancji klasy Base w mainie

int main() {
    Base *test = new Base(1000);

    delete test;
    return 0;
}

valgrind zwraca taki komunikat:

==4809== HEAP SUMMARY:
==4809==    in use at exit: 4,008 bytes in 2 blocks
==4809==   total heap usage: 6 allocs, 4 frees, 84,744 bytes allocated
==4809== 
==4809== LEAK SUMMARY:
==4809==    definitely lost: 8 bytes in 1 blocks
==4809==    indirectly lost: 4,000 bytes in 1 blocks
==4809==      possibly lost: 0 bytes in 0 blocks
==4809==    still reachable: 0 bytes in 0 blocks
==4809==         suppressed: 0 bytes in 0 blocks

Jak więc powinien wyglądać destruktor klasy Base, by nie było wycieków? Dodatkowo nie chcę korzystać z inteligentnych wskaźników.

Z góry dziękuję za każdą pomoc i sugestię.

Answer 1

Chwila... po co w ogóle dynamicznie alokujesz vector? Nie ma potrzeby by to robić, w dodatku to niejako zaprzecza połowie celu jego istnienia. Podobnie nie rozumiem czemu Element dynamicznie alokuje tablicę, jeśli tam też mógłbyś użyć vectora. Podobnie nie rozumiem czemu vector przechowuje wskaźniki... :( Łącznie są tu tu cztery warstwy widocznych wskaźników (plus jedna ukryta w vectorze), a mogłoby być zero (plus dwa w vectorach).

W każdym razie...

list = new std::vector<Element*>(size, new Element(1000));

Tutaj robisz vector wskaźników, ale `new Element(1000)` wykonuje się raz i do każdego elementu vectora przypisujesz ten sam wskaźnik.

        for(int i = 0; i < list->size(); ++i) {
            delete list->at(i);
        }

Z zakomentowanym tym blokiem, nigdy nie zwalniasz wskaźnika zaalokowanego przez `new Element(1000)` - wyciek.

Po odkomendowaniu tego bloku, w pętli robisz delete na każdym elemencie vectora - ale każdy element vectora to ten sam wskaźnik, więc wykonujesz kilkukrotnie delete na tym samym wskaźniku - błąd.

Comments

Dziękuję za odpowiedź!

Jeśli chodzi o wskaźnik na wektor to zapewne masz racje - powinienem stworzyć go statycznie. Nie to było jednak moim celem.

W klasie element tworzę tablicę tylko żeby zaalokować pewien obszar na stercie. Chcę sprawdzać co się skasowało, a co nie.

Prawdziwym problemem okazał się konstruktor wektora, który tworzy wiele wskaźników na ten sam obiekt. Nie tego się spodziewałem. Dziękuję Ci, że swój poświęciłeś czas. Po zaproponowanych przez Ciebie zmianach kod wygląda tak i nie ma wycieków pamięci.

#include <vector>

class Element {
public:
    Element(int num) { val = new int[num]; }

    ~Element() { delete[] val; }
    
private:
    int *val;
};

class Base {
public:
    Base(int size) 
    : list(size) 
    { 
        for(int i = 0; i < size; ++i) {
            list[i] = new Element(1000);
        }
    }

    ~Base() { 
        for(int i = 0; i < list.size(); ++i) {
            delete list[i];
        }
        list.clear();
    }


private:
    std::vector<Element*> list;
};

int main() {
    Base base(1000);
	return 0;
}

 

---

OK. Tylko chciałem podkreślić, że w tym przypadku nie ma dobrego powodu, by używać vector<Element*> zamiast vector<Element>.

---

Oczywiście, że nie ma Tak samo jak sens istnienia całej klasy Element, która tylko alokuje obszar w pamięci i nie pozwala z niej korzystać. Chodziło mi tylko o zrozumienie koncepcji dealokacji takiej struktury. Bo chyba nie da się zaprzeczyć, że czasem przydaje się mieć wektor wskaźników na jakieś obiekty.

W każdym razie.. Szczęśliwego nowego roku!

---

Nazwajem :)

Answer 2

Pomijając fakt tego że program nie jest przemyślany...

#include <vector>

class Element {
public:
    Element(int num)
        : val(new int[num]) {}

    ~Element() { delete[] val; }

private:
    int *val;
};

class Base {
public:
    explicit Base(int size)
        : list(new std::vector<Element*>(size)) {
        for(auto& ptr: *list) {
            ptr = new Element(1000);
        }
    }

    ~Base() {
        for(auto& ptr: *list) {
            delete ptr;
        }
        delete list;
    }
private:
    std::vector<Element*> *list;
};

int main() {
    Base *test = new Base(1000);

    delete test;
}

 

Comments

Hej, Dzięki za odpowiedź.

Jak napisał kolega wyżej - prawdziwy problem tkwił w złym użyciu konstruktora wektora. Cała reszta to tylko przykład - nie chciałem pisać długiego, skomplikowanego i korzystającego z najnowszych rozwiązań programu tylko, żeby pojąć jedną podstawową zasadę. Mimo to dzięki za odpowiedź!