C++ 向量：：清除：内存问题

Vector:：Clear（）将删除向量数组中的元素

问题是，如果我们在vector list中传递对象，Clear（）将删除对象的内存，或者不删除

我发布我的样本：

     CData *m_data = new CData();
     vector<CData*> m_logdata;
     m_logdata.push_back(m_data);
     m_logdata.clear();

CData*m_data=new CData（）；
向量m_对数数据；
m_logdata.向后推（m_data）；
m_logdata.clear（）；

这段代码会删除m_data分配的内存还是仅仅删除向量列表中的元素

问候,，

---

karthik

没有矢量，但有矢量

clear（）将销毁向量中的对象。如果这些对象是指针，则不会删除指向的对象

struct Foo {
};

vector<Foo> vec1;
vector<Foo *> vec2;

vec1.push_back(Foo());
vec2.push_back(new Foo());

vec1.clear(); // Will destruct the Foo instances
vec2.clear(); // Will not delete the pointed to Foo instances

这不会删除您的

CData

实例。它将简单地破坏指针，它是一个no-op

编辑：回应评论

for (size_t p = 0; p < m_logdata.size(); ++p)
  delete m_logdata[p];
m_logdata.clear();

for（size_t p=0；p

这个问题很模糊。。。但无论哪种方式，我猜您都在想，当调用

clear（）

时，存储在

向量中的指针是否会自动删除

事实并非如此。当出现
clear（）
时，存储在
向量中的任何内容都将调用其析构函数。而基元类型（如指针）的析构函数会执行。。没什么

从我的SGI实施中：

/**
 *  Erases all the elements.  Note that this function only erases the
 *  elements, and that if the elements themselves are pointers, the
 *  pointed-to memory is not touched in any way.  Managing the pointer is
 *  the user's responsibilty.
 */
void
clear() { erase(begin(), end()); }

要正确删除任何STL容器中的项目指针，最简单的方法是创建一个函子并将其应用于每个项目：

#include <iostream>
#include <cstdlib>
#include <vector>
#include <functional>
#include <algorithm>

template <typename ValueT>
struct func_delete : public std::unary_function<ValueT,void>
{
  void operator()( ValueT& item ) { delete item; }
};

struct Foo
{
  ~Foo() { std::cout << "Foo::~Foo()" << std::endl; }
};

template <typename ContainerT>
void delete_container( ContainerT& container )
{
  std::for_each( container.begin(), container.end(), func_delete<typename ContainerT::value_type>() );
}

int main( int argc, char** argv )
{
    std::vector<Foo*> foos;

    foos.push_back( new Foo );
    foos.push_back( new Foo );
    foos.push_back( new Foo );

    // Either of these two lines will work
    //std::for_each( foos.begin(), foos.end(), func_delete<Foo*>() );
    //delete_container( foos );

    foos.clear();

    return EXIT_SUCCESS;
}

#包括
#包括
#包括
#包括
#包括
模板
结构函数删除：公共标准：：一元函数
{
void运算符（）（ValueT&item）{delete item；}
};
结构Foo
{
~Foo（）{std:：cout在vector中存储智能指针，您不必担心…@Erik:如何删除CData实例？请提供解决方案。如果您希望存储指针，并且当容器清除时应该删除这些指针，您应该使用某种智能指针，例如boost:：shared\u ptr。这些指针将自动释放其对象如果这些元素被破坏，则执行ect。@karthik:在元素上循环并执行
删除操作。
@Erik:感谢您提供了宝贵的帮助feedback@Erik：Hi Erik，当我在应用程序中尝试时，它抛出运行时异常…我将显示检测到的错误堆损坏：应用程序在堆缓冲区结束后写入内存。如何克服此Erik。
#include <iostream>
#include <cstdlib>
#include <vector>
#include <functional>
#include <algorithm>

template <typename ValueT>
struct func_delete : public std::unary_function<ValueT,void>
{
  void operator()( ValueT& item ) { delete item; }
};

struct Foo
{
  ~Foo() { std::cout << "Foo::~Foo()" << std::endl; }
};

template <typename ContainerT>
void delete_container( ContainerT& container )
{
  std::for_each( container.begin(), container.end(), func_delete<typename ContainerT::value_type>() );
}

int main( int argc, char** argv )
{
    std::vector<Foo*> foos;

    foos.push_back( new Foo );
    foos.push_back( new Foo );
    foos.push_back( new Foo );

    // Either of these two lines will work
    //std::for_each( foos.begin(), foos.end(), func_delete<Foo*>() );
    //delete_container( foos );

    foos.clear();

    return EXIT_SUCCESS;
}