Question

我有一个类真的很复杂，它有一个另一个类的向量。我报告了一个更简单的问题，无论如何它都存在于我能够找到的问题中。

// the inner class
class DuffyDuck{
    int isblack;   // 0 is white, 1 is black
    int n_duck;
    vector<DuffyDuck> * point_Duck;
    public:
    DuffyDuck(int isblack):isblack(isblack){
    }
    void set_point(vector<DuffyDuck> & Abitants){
        point_Duck=&Abitants;
    }
};

// the complessive class

class DuckCity{
     vector<DuffyDuck> DuckAbitants;
     public:
     DuckCity(int numwhite,int numblack){

         for(int i=0;i<(numblack+numwhite);++i){
             DuckAbitants.push_back(DuffyDuck(i>=numblack));
             DuckAbitants[i].set_point(DuckAbitants);
         }

     }
};

现在这个工作了（我在几个函数中使用了point_Duck）但是如果我做了类似的事情，那么在实例中调用后会显示“（* point_Duck）[2] .n_duck;”在一个函数中，项目崩溃。

只有当我这样做时才会发生这种情况：

DuckCity LittleTown(0,0);
LittleTown=DuckCity(3,5);

使用了一些调用指针的函数。

如果我直接做LittleTown（3,5），那一切都是对的。

我希望我解释得很好。

Answer 1

DuffyDuck类正在存储vector<> DuckCity成员的地址。因此，当您将DuckCity复制到另一个实例时，该新实例将具有不同的vector<>实例。但是，该向量中的每个DuffyDuck实例仍具有旧DuckCity实例的一部分地址。

因此，您复制到littleTown会产生悬空指针。

我建议您重新考虑DuffyDuck的设计，或为DuckCity实施一个赋值运算符，为vector<>的每个元素执行深层复制。如果您实现了赋值运算符，请记住也请遵循Rule of Three。

Answer 2

问题的原因是每个 DuffyDuck 都有一个指向DuffyDuck矢量的指针。当类被销毁时，引用变得无效 - ＆gt;崩溃。

DuckCity littleTown(1,2); // this creates a duck city 
                          // with each duck pointing to the DuckAbitans vector.
littleTown=DuckCity(3,5); // this initializes another instance (call it INST) 
                          // of DuckCity and
                          // then it assigns (via = operator) the value to littleTown
                          // by **copying** the DuffyDuck structures into a newly 
                          // allocated vector. This makes the pointer of each DuffyDuck
                          // invalid after INST is destroyed (as it is a temporary object)

Answer 3

复制Abitants的地址时，您将获取DuckCity(3,5)创建的临时对象中的向量地址。然后将此临时对象复制到littleTown，并销毁原始对象。这意味着您的原始Abitats指针指向未使用的内存，这反过来会导致崩溃。

很难确切地说你应该如何解决这个问题 - 可能是通过一个复制构造函数来重建＆＃34;重建＆＃34; Abitats指针。

复制特定类时崩溃

3 个答案: