我应该在这个类中构建一个析构函数吗？

Question

我目前正在使用 C++ 构建 ABM 模型。

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

我当前的实现中的 B 类有一个 po inter 指向包含类 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;
}

那么我的问题是：

我应该在 B 类中实现析构函数/复制构造函数/赋值运算符吗？ A类呢？如果是这样，请您指出正确的语法（对于析构函数，上面的 cmets 会导致段错误）。

我的理解是，这可能是我对指针的“浅”破坏感到满意的情况之一，因为class B 和vector<A> 都将超出返回语句的范围。 class B 拥有指针，该指针在到期时被破坏，向量也是如此。

那么，三人法则中的另一个成员呢？

只计划了一个 B 类对象，但我可能（很小的机会）以后想概括一下。

Answer 1

如果一个类有一个指针类型，你应该实现一个析构函数，我建议也实现一个复制和一个赋值运算符，否则你会从两个不同的地方处理同一个对象，这可能会导致你错误，例如 -

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 上构建一个空向量，这样你就不会遇到段错误，你可以使用 delete。