C++ 删除用户定义的向量-C++；

我有两个类，比如A和B。B类有自己的析构函数。在类A中，我有一个指向类B对象的指针向量。向量如下：

vector<B*> vect;

vect；

在类A的析构函数中，如何检索内存？如果我循环遍历向量，是否检索每个对象并对每个检索到的对象使用delete？我在析构函数中试过了，但它有故障

---

解决这个问题的任何帮助都是非常受欢迎的。很抱歉，我无法发布代码。

是，如果

B*

类型的项指向堆上分配的对象，那么对于每个项，您都应该对其调用delete。

是，如果

B*

类型的项指向堆上分配的对象，那么对于每个项，您都应该对其调用delete。

是，您将循环向量并删除每个项。问题是您忘记了第42行的毛巾操作符。

是的，您将循环向量并删除每个项。问题是您忘记了第42行的Tower运算符。

根据您的描述，您的A类vect成员应该拥有B*所指数据的终身所有权

我建议将该声明更改为

vector< std::tr1::shared_ptr<B> > vect;

vectorvect；

---

编辑：用std:：tr1:：shared_ptr替换了auto_ptr从您的描述来看，您的A类vect成员应该拥有B*所指数据的终身所有权

我建议将该声明更改为

vector< std::tr1::shared_ptr<B> > vect;

vectorvect；

---

编辑：用std:：tr1:：shared_ptr替换自动_ptr

如果A拥有由

vect

指向的内容，那么它应该能够

删除
vect
中的每个项目。如果它在执行此操作时出错，那么代码中的某个地方就有一个bug

不过，总的来说，最好使用智能指针。Boost（的一部分是为您的特定示例而设计的，但是一个简单的
std:：vector
也可以工作（尽管会有更多的开销和更笨拙的语法）.
如果A拥有由
vect
指向的东西，那么它应该能够
删除
vect
中的每个项目。如果它在执行此操作时出现故障，那么代码中的某个地方就有一个bug

不过，一般来说，最好使用智能指针。Boost（的一部分是为您的特定示例而设计的，但是一个简单的
std:：vector
也可以工作（尽管会有更多的开销和更笨拙的语法）。
当您需要管理指针的生命周期时，您希望避免将指针存储在容器中

如果这是一个真正的主人，并保证是最后一个清理，那么我会去

std::vector<B> vect;

std:：vector-vect；

如果您有可能重叠的不同引用和生命周期，那么共享的ptr会更好（std:：tr1或boost取决于编译器）

std:：vectorvect；
当需要管理指针的生命周期时，您希望避免将指针存储在容器中

如果这是一个真正的主人，并保证是最后一个清理，那么我会去

std::vector<B> vect;

std:：vector-vect；

如果您有可能重叠的不同引用和生命周期，那么共享的ptr会更好（std:：tr1或boost取决于编译器）

std:：vectorvect；
其他一些帖子指出，最好使用智能指针而不是指针。如果出于任何原因必须使用指针，则应首先在循环中删除它们

for ( std::vector<B*>::iterator it = vect.begin(); it != vect.end(); ++it)
    delete (*it);
vect.clear();

for（std:：vector:：iterator it=vect.begin（）；it！=vect.end（）；+it）
删除（*它）；
向量清除（）；

编辑：
如果你的程序在析构函数中出现segfault，那么你的代码是错误的。也许你把stack元素按地址放在向量中，但要删除一个对象，它必须在堆上

#include <iostream>
#include <vector>
#include <string>

class data {
public:
    std::string d;
    data(std::string _d) : d(_d) { }
};

class container {
public:
    std::vector<data*> c;
    container() { c.clear(); }
    void add (data *d) { c.push_back(d); }
    ~container() {
        for (std::vector<data*>::iterator it = c.begin(); it != c.end(); ++it)
            delete (*it); 
        c.clear();
    }
};

int main (int argc, char* argv[]) {

    typedef std::vector<std::string> sVec;
    typedef sVec::iterator sVecIter;

    std::vector<std::string> cmd (argv+1, argv+argc);

    {
    container k;            
    for (sVecIter it = cmd.begin(); it != cmd.end(); ++it)
        k.add(new data((*it)));

    }

    return 0;

}

#包括
#包括
#包括
类数据{
公众：
std：：字符串d；
数据（std:：string d）：d（d）{
};
类容器{
公众：
std：：向量c；
容器（）{c.clear（）；}
void add（data*d）{c.push_back（d）；}
~container（）{
对于（std:：vector:：iterator it=c.begin（）；it！=c.end（）；++it）
删除（*它）；
c、 清除（）；
}
};
int main（int argc，char*argv[]）{
typedef std：：向量sVec；
typedef sVec:：迭代器sVecIter；
std:：vector cmd（argv+1，argv+argc）；
{
容器k；
对于（sVecIter it=cmd.begin（）；it！=cmd.end（）；++it）
k、 添加（新数据（（*it））；
}
返回0；
}

这没有问题。
其他一些帖子指出，最好使用智能指针而不是指针。如果出于任何原因必须使用指针，则应首先在循环中删除它们

for ( std::vector<B*>::iterator it = vect.begin(); it != vect.end(); ++it)
    delete (*it);
vect.clear();

for（std:：vector:：iterator it=vect.begin（）；it！=vect.end（）；+it）
删除（*它）；
向量清除（）；

编辑：
如果你的程序在析构函数中出现segfault，那么你的代码是错误的。也许你把stack元素按地址放在向量中，但要删除一个对象，它必须在堆上

#include <iostream>
#include <vector>
#include <string>

class data {
public:
    std::string d;
    data(std::string _d) : d(_d) { }
};

class container {
public:
    std::vector<data*> c;
    container() { c.clear(); }
    void add (data *d) { c.push_back(d); }
    ~container() {
        for (std::vector<data*>::iterator it = c.begin(); it != c.end(); ++it)
            delete (*it); 
        c.clear();
    }
};

int main (int argc, char* argv[]) {

    typedef std::vector<std::string> sVec;
    typedef sVec::iterator sVecIter;

    std::vector<std::string> cmd (argv+1, argv+argc);

    {
    container k;            
    for (sVecIter it = cmd.begin(); it != cmd.end(); ++it)
        k.add(new data((*it)));

    }

    return 0;

}

#包括
#包括
#包括
类数据{
公众：
std：：字符串d；
数据（std:：string d）：d（d）{
};
类容器{
公众：
std：：向量c；
容器（）{c.clear（）；}
void add（data*d）{c.push_back（d）；}
~container（）{
对于（std:：vector:：iterator it=c.begin（）；it！=c.end（）；++it）
删除（*它）；
c、 清除（）；
}
};
int main（int argc，char*argv[]）{
typedef std：：向量sVec；
typedef sVec:：迭代器sVecIter；
std:：vector cmd（argv+1，argv+argc）；
{
容器k；
对于（sVecIter it=cmd.begin（）；it！=cmd.end（）；++it）
k、 添加（新数据（（*it））；
}
返回0；
}

这项工作没有问题。
vector
加上
auto_ptr
是个坏主意：
auto_ptr
不适用于标准容器，因为它的复制行为很奇怪。
std:：tr1: