Как избежать утечки памяти при использовании вектора указателей на динамически выделенные объекты в C++?

std::vector будет управлять памятью для вас, как всегда, но эта память будет указателей, а не объектов.

это означает, что ваши классы будут потеряны в памяти, как только ваш вектор выйдет из области видимости. Например:

#include <vector>

struct base
{
    virtual ~base() {}
};

struct derived : base {};

typedef std::vector<base*> container;

void foo()
{
    container c;

    for (unsigned i = 0; i < 100; ++i)
        c.push_back(new derived());

} // leaks here! frees the pointers, doesn't delete them (nor should it)

int main()
{
    foo();
}

что вам нужно сделать, это убедиться, что вы удалите все объекты, прежде чем вектор выходит из области видимости:

#include <algorithm>
#include <vector>

struct base
{
    virtual ~base() {}
};

struct derived : base {};

typedef std::vector<base*> container;

template <typename T>
void delete_pointed_to(T* const ptr)
{
    delete ptr;
}

void foo()
{
    container c;

    for (unsigned i = 0; i < 100; ++i)
        c.push_back(new derived());

    // free memory
    std::for_each(c.begin(), c.end(), delete_pointed_to<base>);
}

int main()
{
    foo();
}

это трудно поддерживать, хотя, потому что мы должны помнить, чтобы выполнить некоторое действие. Что еще более важно, если исключение должно было произойти между выделением элементов и циклом освобождения, цикл освобождения никогда не будет выполняться, и вы все равно застряли с утечкой памяти! Это называется безопасностью исключений, и это критическая причина, по которой освобождение должно выполняться автоматически.

лучше было бы, если бы указатели удалялись сами. Тезисы называются интеллектуальными указателями, а стандартная библиотека предоставляет std::unique_ptr и std::shared_ptr.

std::unique_ptr представляет собой уникальный (неразделенный, однопользовательский) указатель на некоторый ресурс. Это должен быть ваш смарт-указатель по умолчанию и общая полная замена любого использования необработанного указателя.

auto myresource = /*std::*/make_unique<derived>(); // won't leak, frees itself

std::make_unique отсутствует в стандарте C++11 по недосмотру, но вы можете сделать его самостоятельно. Чтобы непосредственно создать unique_ptr (не рекомендуется свыше make_unique если вы можете), сделайте следующее:

std::unique_ptr<derived> myresource(new derived());

уникальные указатели имеют семантику перемещения только; они не могут быть скопированы:

auto x = myresource; // error, cannot copy
auto y = std::move(myresource); // okay, now myresource is empty

и это все, что нам нужно использовать его в контейнер:

#include <memory>
#include <vector>

struct base
{
    virtual ~base() {}
};

struct derived : base {};

typedef std::vector<std::unique_ptr<base>> container;

void foo()
{
    container c;

    for (unsigned i = 0; i < 100; ++i)
        c.push_back(make_unique<derived>());

} // all automatically freed here

int main()
{
    foo();
}

shared_ptr имеет семантику копии подсчета ссылок; это позволяет нескольким владельцам совместно использовать объект. Он отслеживает, сколько shared_ptrS существует для объекта, и когда последний перестает существовать (этот счетчик переходит в ноль), он освобождает указатель. Копирование просто увеличивает количество ссылок (а перемещение передает право собственности по более низкой, почти бесплатной цене). Вы делаете их с std::make_shared (или непосредственно, как показано выше, а потому что shared_ptr должен внутренне выделять ассигнования, это, как правило, более эффективно и технически более безопасно для использованияmake_shared).

#include <memory>
#include <vector>

struct base
{
    virtual ~base() {}
};

struct derived : base {};

typedef std::vector<std::shared_ptr<base>> container;

void foo()
{
    container c;

    for (unsigned i = 0; i < 100; ++i)
        c.push_back(std::make_shared<derived>());

} // all automatically freed here

int main()
{
    foo();
}

помните, что вы обычно хотите использовать std::unique_ptr по умолчанию, потому что он более легкий. Кроме того, std::shared_ptr может быть построен из std::unique_ptr (но не наоборот), так это нормально, чтобы начать с малого.

кроме того, вы можете использовать контейнер, созданный для хранения указателей к объектам, таким как boost::ptr_container:

#include <boost/ptr_container/ptr_vector.hpp>

struct base
{
    virtual ~base() {}
};

struct derived : base {};

// hold pointers, specially
typedef boost::ptr_vector<base> container;

void foo()
{
    container c;

    for (int i = 0; i < 100; ++i)
        c.push_back(new Derived());

} // all automatically freed here

int main()
{
    foo();
}

пока boost::ptr_vector<T> имел явные использовать в C++03, Я не могу говорить об актуальности сейчас, потому что мы можем использовать std::vector<std::unique_ptr<T>> вероятно, с незначительными или несопоставимыми накладными расходами, но это утверждение должно быть проверено.

несмотря ни на что,никогда явно свободные вещи в коде. Оберните вещи, чтобы убедиться, что управление ресурсами обрабатывается автоматически. У вас не должно быть сырых указателей на владение в вашем код.

по умолчанию в игре, я бы, вероятно, пошел с std::vector<std::shared_ptr<T>>. Мы ожидаем обмена в любом случае, это достаточно быстро, пока профилирование не скажет иначе, это безопасно и легко использовать.