内存泄漏 - STL 集

Question

我正在尝试堵住所有内存泄漏（这是巨大的）。我是STL新手。我有一个班级图书馆，里面有 3 套。我还在库类中使用 new 创建了大量内存，用于向集合添加信息...

我需要取消分配集合吗？如果是这样，怎么办？

这是library.h

    #pragma once

#include <ostream>
#include <map>
#include <set>
#include <string>
#include "Item.h"

using namespace std;

typedef set<Item*>              ItemSet;
typedef map<string,Item*>       ItemMap;
typedef map<string,ItemSet*>    ItemSetMap;

class Library
{

public:
    // general functions

    void addKeywordForItem(const Item* const item, const string& keyword);
    const ItemSet* itemsForKeyword(const string& keyword) const;
    void printItem(ostream& out, const Item* const item) const;

    // book-related functions

    const Item* addBook(const string& title, const string& author, int const nPages);
    const ItemSet* booksByAuthor(const string& author) const;
    const ItemSet* books() const;

    // music-related functions

    const Item* addMusicCD(const string& title, const string& band, const int nSongs);
    void addBandMember(const Item* const musicCD, const string& member);
    const ItemSet* musicByBand(const string& band) const;
    const ItemSet* musicByMusician(const string& musician) const;
    const ItemSet* musicCDs() const;

    // movie-related functions

    const Item* addMovieDVD(const string& title, const string& director, const int nScenes);
    void addCastMember(const Item* const movie, const string& member);
    const ItemSet* moviesByDirector(const string& director) const;
    const ItemSet* moviesByActor(const string& actor) const;
    const ItemSet* movies() const;
    ~Library();
};

我不确定我需要为析构函数做什么？

Library::~Library()
{


}

另外，我是否正确分配了字符串集？

    #ifndef CD_H
#define CD_H
#pragma once
#include "item.h"
#include <set>


typedef set<string> StringSet;


class CD : public Item
{
public:

    CD(const string& theTitle, const string& theBand, const int snumber);
    void addBandMember(const string& member);
    const int getNumber() const;
    const StringSet* getMusician() const;
    const string getBand() const;
    virtual void print(ostream& out) const;
    string printmusicians(const StringSet* musicians) const;

    ~CD();


private:

    string band;
    StringSet* music;

    string title;
    int number;

};

ostream& operator<<(ostream& out, const CD* cd);

#endif

库类中的cd.cpp

    #include "CD.h"

using namespace std;

CD::CD(const string& theTitle, const string& theBand, const int snumber)
: Item(theTitle), band(theBand),number(snumber), music(new StringSet)
{



}

CD::~CD()
{

    delete []music;

}

我创建了大量内存，但析构函数不会清理它吗？ 示例：

    const Item* Library::addBook(const string& title, const string& author, const int nPages)
{

    ItemSet* obj = new ItemSet();
    Book* item = new Book(title,author,nPages);
    allBooks.insert(item); // add to set of all books
    obj->insert(item);

注意：我没有复制构造函数。我不确定我是否需要一个或如何添加一个。我认为我的析构函数也没有被调用。

Answer 1

STL 容器不是为保存指针而设计的。

查看 boost 指针容器。这些容器被设计用来保存指针。

#include <boost/ptr_container/ptr_set.hpp>
#include <boost/ptr_container/ptr_map.hpp>

http://www.boost.org/doc/ libs/1_42_0/libs/ptr_container/doc/ptr_set.html

容器保存并拥有指针，因此当容器超出范围时它们将被删除。但容器的美妙之处在于，您可以通过引用访问对象，因此所有标准算法都可以在没有任何特殊适配器的情况下工作。

typedef boost::ptr_set<Item>              ItemSet;
typedef boost::ptr_map<string,Item>       ItemMap;
typedef boost::ptr_map<string,ItemSet>    ItemSetMap;

附言。很难准确地判断，但看起来有太多接口返回指针。在 C++ 中实际返回指针（或传递指针）的情况非常罕见。您的接口通常应采用对象/引用或智能指针（通常按此顺序，但取决于情况）。

使用指针应该是最后的手段，因为没有明确指示对象的所有者，因此清理成为问题（从而导致大量内存泄漏）。

Answer 2

您需要释放集合中每个元素的内存。容器不会为您执行此操作，也不应该这样做，因为它无法知道它是否拥有该数据 - 它可能只是保存指向其他对象所拥有的对象的指针。

这是一个通用的自由函数，可以释放任何 STL 容器。

template <typename T>
void deallocate_container(T& c)
{
  for (typename T::iterator i = c.begin(); i != c.end(); ++i)
    delete *i;
}

// Usage
set<SomeType*> my_set;
deallocate_container(my_set);
my_set.clear();

Answer 3

还没有浏览完您的所有代码，但从前几行看来您正在维护指针集。每当您有一个保存指针的 STL 容器并且您使用 new 将内容放入指针时，您必须使用 delete 来释放这些指针。 STL 不会为你做这些事。事实上，STL 甚至不知道它们是指针。

另一种选择是根本不使用指针，只使用一组对象，而不使用 new 来创建它们。只需在堆栈上创建它们并将它们复制到集合中即可。

Answer 4

好吧，这可能是一个愚蠢的评论，但是您真的需要将所有内容都堆分配（又名。使用指针和 new 吗？）

您不能只使用普通实例吗？ RAII 允许更简单的代码并且没有内存泄漏。

例如：

using namespace std;

typedef set<Item>              ItemSet;
typedef map<string,Item>       ItemMap;
typedef map<string,ItemSet>    ItemSetMap;

class Library
{

public:
    // general functions

    void addKeywordForItem(const Item & item, const string& keyword);
    ItemSet itemsForKeyword(const string& keyword) const;
    void printItem(ostream& out, const Item & item) const;

    // book-related functions

    Item addBook(const string& title, const string& author, int nPages);
    ItemSet booksByAuthor(const string& author) const;
    ItemSet books() const;

    // music-related functions

    Item addMusicCD(const string& title, const string& band, int nSongs);
    void addBandMember(const Item & musicCD, const string& member);
    ItemSet musicByBand(const string& band) const;
    ItemSet musicByMusician(const string& musician) const;
    ItemSet musicCDs() const;

    // movie-related functions

    Item addMovieDVD(const string& title, const string& director, int nScenes);
    void addCastMember(const Item & movie, const string& member);
    ItemSet moviesByDirector(const string& director) const;
    ItemSet moviesByActor(const string& actor) const;
    ItemSet movies() const;
    ~Library();
};

使用这种方法，析构函数必须严格不执行任何操作，并且不会发生内存泄漏。在大多数情况下，可以轻松避免使用指针，而且绝对应该这样做！

Answer 5

查看您在其他问题中发布的一些代码（例如 https://stackoverflow.com/ questions/2376099/c-add-to-stl-set），您的项目存储在多个全局 ItemSet 对象中。这不是一个好的设计 - 它们确实应该是 Library 对象的一部分，因为它们在逻辑上属于该对象。

修复内存泄漏的最佳方法不是处理原始指针 - 要么将智能指针存储在集合中，要么按照 Martin York 的建议使用 Boost 指针容器。另外，您的 ItemSetMap 对象应该包含 Set 对象而不是指针 - 绝对没有理由在其中存储指针。

如果您确实必须存储指针，那么您的析构函数必须遍历每个集合以删除内容：

void Purge(ItemSet &set)
{
    for (ItemSet::iterator it = set.begin(); it != set.end(); ++it)
        delete *it;
    set.clear(); // since we won't actually be destroying the container
}

void Purge(ItemSetMap &map)
{
    for (ItemSetMap::iterator it = map.begin(); it != map.end(); ++it)
        delete it->second;
    map.clear();
}

Library::~Library()
{
    Purge(allBooks);
    Purge(allCDs);
    // and so on and so forth
}

但这确实不是您应该这样做的方式，正如几乎每个回答您问题的人都指出的那样。

至于 StringSet，您是使用普通的 new 而不是 new[] 创建的，因此您必须使用普通的 delete 删除它代码>而不是删除[]。或者，更好的是，将 music 设为 StringSet 对象而不是指针，那么您根本不需要析构函数。再次强调，通过原始指针和手动使用删除进行内存管理很容易出错，应该尽可能避免。

Answer 6

在析构函数中，您需要迭代包含指针的 stl 集合并删除它们。像这样：

while (!collection.empty()) {
    collection_type::iterator it = collection.begin();
    your_class* p = *it;
    collection.erase(it);
    delete p;
}

Answer 7

正如其他人所指出的，您需要取消分配指针。 set 析构函数通常不会为您执行此操作。否则，如果您希望为您完成此操作，请使用 boost::scoped_ptr 或 std::tr1::shared_ptr，您可以在其中指定自定义删除器来执行此操作这份工作适合你。