C++ 在类构造函数中填充向量

Question

我在 Class3 的对象中处理元素时遇到麻烦，请查看这个简化的类：

class Class1 {
public:
    std::vector<Class2> c2v;
    Class1();
};

class Class2 {
    Class1 *instance;
    int id;
public:
    std::vector<Class3> c3v;
    Class2 ( Class1 *instance, int id );
};

class Class3 {
    Class1 *instance;
    int id;
public:
    Class3 ( Class1 *instance, int id );
};

及其构造函数：

Class1::Class1()
{
    for ( int i = 0; i < noi; ++i ) {
        c2v.push_back ( Class2 ( this, i ) );
    }
}

Class2::Class2 ( Class1 *instance, int id )
{
    this->instance = instance;
    this->id = id;

    for ( int k = 0; k < nok; ++k ) {
        c3v.push_back ( Class3 ( this->instance, k ) );
    }
}

在 main() 中，Class1 的对象使用其默认构造函数进行实例化。因此它创建了一个向量 c2v 并用 Class2 的“noi”对象填充它。

同时，当 Class2 的对象被放入 c2v 向量时，它们会被实例化，并且每个都创建一个向量 c3v 并用 Class3 的“非”对象填充它。

代码编译良好，但在运行时从 Class3 对象（通过this->instance->c2v[0].getSomeAttribute()）访问 Class2 的公共属性时，程序会以 EXC_BAD_ACCESS 停止。

使用调试器检查表明指向c2v[0] 的指针已损坏（其值变为0x0）。

我是 C++ 的新手，我想知道尝试以这种方式实例化向量时会出现什么错误。我应该只声明向量并在 Class2 和 Class3 的所有实例创建完成后调用的单独函数中填充它们吗？

我正在添加一些实际代码，希望阅读不会太长（请理解我省略了一些前向声明和预处理器指令）：

// global variables
extern char *filename; //not used
extern int nodes;
extern int numProdotti;
extern int classe; //not used
extern int maxNumRange; //not used
extern int *numRanges;
extern int *list ;
extern int *typeProdMarket;
extern int totalQtyDemand; //not used
extern int totNumRanges; //not used

extern struct product {
    int     qty;
    int     cost;
} **prodMarket;

extern struct range {
    int     discount;
    int     startOfRange;
} **rangeMarket; //not used

int main ( int argc, char *argv[] )
{
    Ctqd instance;
    instance.runOpt();
}

class Ctqd {
    void greedySimple();
    void greedySimpleReverse();
    void greedyFromY();
    void greedyByNiceness1();
    void greedyByNiceness2();
    void greedyByStepTier1();
    void greedyByStepTier2();
    void randomLocalSearch1();
    void LocalSearch2opt();
public:
    std::vector<Item> items;
    std::vector<Supplier> suppliers;
    Solution *solution;
    Ctqd();
    ~Ctqd();
    void runOpt();
};

class Supplier {
    Ctqd *instance;
    int id;
    int refTotQty;
    int refDiscount;
    int refDiscountTier;
    double refTotPrice;
    double refUnitPrice;
    double niceness;
    int purTotQty;
    int purDiscount;
    int purDiscountTier;
public:
    std::vector<Offer> offers;
    Supplier ( Ctqd *instance, int id );
    int getId();
    int getRefTotQty();
    int getRefDiscount();
    int getRefDiscountTier();
    double getRefTotPrice();
    double getRefUnitPrice();
    double getNiceness();
    int getPurTotQty();
    int getPurDiscount();
    int getPurDiscountTier();
    void updateStats();
};

class Offer {
    Supplier *supplier;
    int id;
    int refQty;
    double refPrice;
    double niceness;
    int purQty;
public:
    Offer ( Supplier *supplier, int id );
    int getId();
    int getRefQty();
    double getRefPrice();
    double getNiceness();
    int getPurQty();
    void setPurQty ( int qty );
    int remainingQty();
};

Ctqd::Ctqd()
{
    // constructing items vector
    for ( int k = 0; k < numProdotti; ++k ) {
        items.push_back ( Item ( this, k ) );
    }

    // constructing suppliers vector
    for ( int i = 0; i < nodes; ++i ) {
        suppliers.push_back ( Supplier ( this, i ) );
    }

    // building solution
    solution = new Solution ( this );
}

Supplier::Supplier ( Ctqd *instance, int id )
{
    this->instance = instance;
    this->id = id;
    // computing total reference quantity
    refTotQty = 0;

    for ( int k = 0; k < numProdotti ; ++k ) {
        refTotQty += std::min ( list[ k ] , prodMarket[ this->id ][ k ].qty );
    }

    // computing reference discount coefficients
    refDiscount = 0;
    refDiscountTier = 0;

    for ( int r = 0; r < numRanges[ this->id ]; ++r ) {
        if ( refTotQty < rangeMarket[ this->id ][ r ].startOfRange ) {
            break;
        }
        else {
            refDiscount = rangeMarket[ this->id ][ r ].discount;
            refDiscountTier = r;
        }
    }

    //computing total reference price
    refTotPrice = 0;

    for ( int k = 0; k < numProdotti ; ++k ) {
        refTotPrice += prodMarket[ this->id ][ k ].cost * std::min ( list[ k ] , prodMarket[ this->id ][ k ].qty );
    }

    refTotPrice = refTotPrice * ( 1.000 - refDiscount / 100.000 );
    //computing reference unit price
    refUnitPrice = refTotPrice / refTotQty;
    //computing supplier niceness
    niceness = refTotQty / refUnitPrice;
    purTotQty = 0;
    purDiscount = 0;
    purDiscountTier = 0;

    // building offers vector
    for ( int k = 0; k < numProdotti; ++k ) {
        offers.push_back ( Offer ( this, k ) );
    }
}

Offer::Offer ( Supplier *supplier, int id )
{
    this->supplier = supplier;
    this->id = id;
    // computing reference quantity
    refQty = std::min ( list[ this->id ] , prodMarket[ this->supplier->getId() ][ this->id ].qty );
    // computing reference price
    refPrice = prodMarket[ this->supplier->getId() ][ this->id ].cost * ( 1.000 - this->supplier->getRefDiscount() / 100.000 );
    // computing niceness of the offer
    niceness = refQty / ( ( prodMarket[ this->supplier->getId() ][ this->id ].cost + refPrice ) / 2 );
    // init purQty to 0
    purQty = 0;
}

这是我获得 EXC_BAD_ACCESS 的地方：

int Offer::remainingQty()
{
    return prodMarket[ supplier->getId() ][ id ].qty - purQty;
}

我做了一些实验： 将 Ctqd 类和 Supplier 类中的向量更改为指向对象的向量。 问题仅部分解决。 构造 offer 对象时仍然有 EXC_BAD_ACCESS。

Offer 类的构造函数需要来自创建它的 Supplier 对象的数据。 我认为在仍在填充供应商向量时访问该数据可能会导致问题，因此我在供应商中创建了一个小初始化（）函数：

void Supplier::initialize()
{
    // constructing offers vector
    for ( int k = 0; k < numProdotti; ++k ) {
        offers.push_back ( new Offer ( this->instance, id, k ) );
    }
}

并在 Ctqd 类构造函数的末尾添加了这个：

// init newly built objects
for ( int i = 0; i < nodes; ++i ) {
    suppliers[i]->initialize();
}

现在似乎一切正常。但是我还是没有弄清楚到底是什么问题。

Answer 1

到目前为止，最简单（也是最好）的解决方法是使用std::deque 而不是std::vector。您不需要使用指针；你可以坚持原来的推物计划。

使用双端队列，push_back 保证不会使对其元素的引用无效。实际上，push_front 也是如此。并且它仍然支持恒定时间随机访问（foo[n]）。

在逐步构建一个装满对象的容器时，通常需要双端队列。

一般来说，std::deque 可能是您从未使用过的最佳数据结构。

Answer 2

您没有遵守规则 3。您应该为所有类实现析构函数、复制构造函数和赋值运算符。

考虑这条线：

c2v.push_back ( Class2 ( this, i ) );

这将创建一个临时对象，对其进行复制并将其放入向量中。副本和临时对象将通过实例成员指向同一位置。但是，当临时对象被销毁时（就在下一行之前），该内存被释放并可供使用。因此，现在您的向量中将有一个 Class2 类型的对象，其字段无效。

这只是我的猜测。如果这没有帮助，请在 main 中发布代码。

Answer 3

对于初学者，您的代码将无法编译：当编译器遇到 Class1::c2v, Class2 的声明是一个未知符号。如果我添加 前向声明（以及noi 的定义），它仍然包含 未定义的行为，并且不能用 g++ 编译，至少不能用 常用选项。实例化标准模板是非法的 不完整的类型。由于您的类型具有循环依赖关系，因此您是 将不得不在某处使用指针。

另外，Class2 和 Class3 中的指针在 对象被复制（并且std::vector 将被复制）。从你的评论 制造（Class2 代表供应商，Class3 代表报价）， 这些类可能应该是不可复制的。这在很大程度上取决于 设计，但在大多数情况下，实体类对问题进行建模 域，应该是不可复制的。这也导致使用指针 他们，而不是副本。 （引用语义，而不是值 语义。）

当然，使用指针确实会引入对象生命周期的问题。 您必须决定供应商和报价何时以及如何进入 存在，以及它们何时停止存在。这应该是您的一部分 设计。

Answer 4

虽然向量内容的重定位和Class2 或Class3 对象的复制不应该产生任何问题（与其他答案可能说明的相反），但当您创建@ 的本地对象时会出现问题987654323@ 并复制它。当您现在尝试通过instance 指针之一访问原始Class1 对象时，该对象可能已经被销毁，因此对其成员之一的访问会导致段错误。

Answer 5

改变

std::vector<Class2> c2v;

到

std::vector<Class2 *> c2v;

和

std::vector<Class3> c3v;

到

std::vector<Class3*> c3v;

问题是您正在获取矢量内的本地对象的地址。当向量需要更多空间时，它会重新分配他的内存，因此 Class2 和 Class3 对象的地址发生了变化。

class Class1 {
public:
    std::vector<Class2 *> c2v;
    Class1();
};

class Class2 {
    Class1 *instance;
    int id;
public:
    std::vector<Class3 *> c3v;
    Class2 ( Class1 *instance, int id );
};

class Class3 {
    Class1 *instance;
    int id;
public:
    Class3 ( Class1 *instance, int id );
};


Class1::Class1()
{
    for ( int i = 0; i < noi; ++i ) {
        c2v.push_back ( new Class2 ( this, i ) );
    }
}

Class2::Class2 ( Class1 *instance, int id )
{
    this->instance = instance;
    this->id = id;

    for ( int k = 0; k < nok; ++k ) {
        c3v.push_back ( new Class3 ( this->instance, k ) );
    }
}

别忘了清理 Class1' 和 Class2' 析构函数。

编辑： 为什么会出现这种奇怪的行为：

第一步

Ctqd::Ctqd()
{
    for ( int i = 0; i < nodes; ++i ) {
        suppliers.push_back ( Supplier ( this, i ) ); // <-- Supplier's constructor is invoked here
                                                // to construct automatic object of Supplier class
    }
}

第 2 步。我们在自动对象的构造函数内部：

Supplier::Supplier ( Ctqd *instance, int id )
{
    for ( int k = 0; k < numProdotti; ++k ) {
        offers.push_back ( Offer ( this, k ) ); // consider that we are passing this to 
                                               // Offer's constructor. this is a pointer to
                                              // automatic variable
    }
}

第 3 步。返回第 1 步。但是现在我们已经创建了自动对象供应商

Ctqd::Ctqd()
{
    for ( int i = 0; i < nodes; ++i ) {
        suppliers.push_back ( Supplier ( this, i ) ); // <-- automatic object of class Supplier
                                                     // is created. Now as long as push_back() taking
                                                    // parameter by value yo are passing copy of
                                                   // automatic object to push_back();
                                                  // as long as you didn't define copy constructor
                                                 // for Supplier compiler adds default for you.
    }
}

步骤 4. 自动对象的副本保存到suppliers 向量。新对象（自动对象的副本）的向量 offers 与我们的自动对象的值完全相同（感谢向量的复制构造函数）。所以每个对象都有成员supplier 指向...（geass what :)）正确！它们都指向自动对象。

Ctqd::Ctqd()
{
    for ( int i = 0; i < nodes; ++i ) {
        suppliers.push_back ( Supplier ( this, i ) ); // <-- magic here
    }
}

第 5 步。自动对象已被破坏（还记得您如何将指向该对象的指针传递给 Offer 的构造函数吗？）。哎呀你说。

Ctqd::Ctqd()
{
    for ( int i = 0; i < nodes; ++i ) {
        suppliers.push_back ( Supplier ( this, i ) ); 
                                                      // <-- automatic doesn't exist no more
    }
}

如果供应商的方法之一试图通过supplier 成员访问Supplier 对象会发生什么（我们，聪明的孩子，知道指向死对象……太伤心了……QQ）。猜测。我相信它会因为意识到他有生以来第一次看到死物而死；）。