Class 我应该在这个类中构建析构函数吗？ 我目前正在使用C++构建一个ABM模型。

我有一些类需要相互交互，因为例如，类B需要检查类A中的值并返回一些对其的评估，然后类C可能需要读取这些值。类不需要更改其他类的值，只需要从中读取

我当前实现中的类B有一个po 指向一个包含类a的所有成员的向量。指针在那里有两个原因：它使初始化向量更容易，而向量留在main的范围内，这样我就可以访问并循环它，为每个代理调用类a的成员

我的MCVE：

#include <iostream> 
#include <vector>

using namespace std;

class A;    // Forward declaration

class B{

    int id,
    some_value;

    vector<A> * A_vec;

public:

// Overloaded constructor
    B(int ID, vector<A> & PTR)
    {   
    A_vec = & PTR;
    id = ID;
    some_value = 0;
    };

// Copy Constructor
    B( const B& that ):
    id(that.id),
    some_value(that.some_value)
    {
    // Pointer ??
    };

// Non-default destructor -> uncomment leads to seg_fault
    /*
    ~B(){   delete [] A_vec;};
    */
// Assignment operator

    B& operator=(const B& that)
    {
        id = that.id;
        some_value = that.some_value;
    // Pointer ??
        return *this;
    };

//Methods to update different variables go here ..
    void do_stuff();

};

class A{

    B & class2_ref;
    vector<double> o;


public:

    int stuff;

// Overloaded constructor

    A(int STUFF, B & REF, vector<double> O):

    class2_ref(REF),
    o(O)

    {
        stuff = STUFF;  
    };

// Methods to update different variables go here ..
};  

void B::do_stuff()
{
    int L = A_vec->size();  
    for(int l = 0; l<L; l++)  some_value += (*A_vec)[l].stuff; // Perform some operation

};


int main(){

    int I = 5;          // Number of objects of A

    vector<double> O(12,2); // Some numbers in here

    B b(0,A_vec);

    for(int i = 0; i< I; i++)
    {
        A a(i,b,O);
        A_vec.push_back(a);
    }

    b.do_stuff();

    cout<< "Debugging MCVE" << endl;

    return 0;
}

#包括
#包括
使用名称空间std；
A类；//远期申报
B类{
int id，
一些价值观；
向量*A_向量；
公众：
//重载构造函数
B（内部ID、向量和PTR）
{   
A_vec=&PTR；
id=id；
某些_值=0；
};
//复制构造函数
B（const B&that）：
id(即,id),，
一些价值（即一些价值）
{
//指针？？
};
//非默认析构函数->取消注释导致seg_故障
/*
~B（）{delete[]A_vec；}；
*/
//赋值运算符
B&运算符=（常数B&that）
{
id=that.id；
some_value=that.some_value；
//指针？？
归还*这个；
};
//用于更新不同变量的方法位于此处。。
虚空做某事；
};
甲级{
B&2级参考；
向量o；
公众：
智力材料；
//重载构造函数
A（整型，B&REF，向量O）：
第2类参考（参考），
o（o）
{
东西=东西；
};
//用于更新不同变量的方法位于此处。。
};  
void B:：do_stuff（）
{
int L=A_vec->size（）；
对于（int l=0；l如果类具有指针类型，则应实现析构函数，我建议还应实现副本和赋值运算符，否则将从两个不同的位置处理同一对象，例如，这可能会导致一些错误-

void someFunction(B &b)
{
  B a = b;
}

B b(0,A_vec);
someFunction(b); //After finishing someFunction, it will try to delete the vector from a , but it is the same vector you used in b.
b.do_stuff(); // Would cause a seg error

对于析构函数语法，只需删除向量，而不是其内容，它将在内容上使用向量默认析构函数：

delete A_vec

如果没有初始化，请确保不要使用它，我建议在类的每个ctor上只构建一个空向量，这样你就不会出现seg错误，你可以使用delete。
请先格式化你的代码。另外，没有必要删除一个你永远都不会更新的指针，这可以解释segfault@SoheilHassasYeganeh我格式化了它，希望现在更好。@Alejandro我想这就是segfault的原因。不过我想知道，因为我一直在读原始指针数据成员，所以需要在析构函数中小心处理。所以，考虑到构造函数中初始化它的方式，它是安全的？复制呢？你必须释放你想要的东西吗u分配。最好是首先分配的人将是要取消分配的人。这是RAII（资源获取是初始化）的含义之一在dtor中使用
delete A_vec
，并且类位于其所在位置时，会导致双重自由错误。此外，我希望将指针保留在类内，以指向类外的向量。我不希望在类内有另一个向量，也不希望只在类内有一个向量。我假设您希望lize，如你所说，因此有超过1b，请记住delete[]和delete之间的不同，使用delete A_vec将删除向量内容，使用delete[]一个_-vec将尝试在一个_-vec的每个成员上使用一个dtor，而不使用任何东西只会删除指针，将向量留在堆中。我明白了，但我仍然希望类外有多个向量。一般来说，如果类中有*类型，则需要一个dtor，否则将出现内存泄漏（如果你不在其他地方处理它），我也建议不要有一个作为成员的参考，也编辑了上一条评论，该死的enter导致它被提前发送：）一般来说，是的。在这里呢？我目前的理解是，我上面的内容是安全的。我在main中有一个向量。我在类中有一个指针。指针只是一个保存内存地址的变量。在return语句中，类被销毁，默认dtor负责指针，但不接触向量。然后向量被删除stroed，再次调用其默认析构函数。