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级怎么样？如果是这样，请指点我正确的语法（对于析构函数，上面的注释会导致seg错误）。

我的理解是，这可能是我对指针的“浅层”破坏感到满意的情况之一，因为class B和vector<A>都会在返回时超出范围声明。 class B拥有指针，它在到期时被破坏，而向量则相同。

但是，那么三个规则中的另一个成员呢？

B计划只有一个对象计划，但我可能（小机会）想要稍后概括。

Answer 1

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

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

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

delete A_vec

如果没有初始化，请确保你不要使用它，我建议只在类的每个ctor上构建一个空向量，这样你就不会出现seg错误，你可以使用delete。

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

1 个答案: