C++ c++；创建新对象时：迭代器不可递增

我正在处理一项任务，创建一个兔子队伍，在那里它们可以在每一轮繁殖。所以我定义了一类

Bunny

（个体），然后定义了一类

team

，其中一个向量指向不同的Bunny。 我的问题是，每次使用

new

在循环中创建对象兔子时，都会出现一个错误，显示：

“调试断言失败！！…向量迭代器不可递增…”

以下是我的代码示例：

class Bunny {
private:
    string sex;
    string color;
    string name;
    int age;
public:
    string getname() { return name;};
    Bunny(); // constructor
};

class Troop {
private:
    vector<Bunny *> bunpointer;
    vector<Bunny *>::iterator it;
public:
    void newbunny();
    void multiply();
};

void Troop::newbunny() {
    Bunny * bun;  // pointer to the Bunny class
    bun = new Bunny;
    cout << "Bunny " << bun->getname() << " is born! \n";
    bunpointer.push_back(bun);
}

void Troop::multiply() {
    it = bunpointer.begin();
    while(it!=bunpointer.end()) {
        cout << (*it)->getname() << " gave a birth. ";
        newbunny();
        ++it;
    }
    it = bunpointer.begin();
}

类兔子{
私人：
弦性；
字符串颜色；
字符串名；
智力年龄；
公众：
字符串getname（）{return name；}；
Bunny（）；//构造函数
};
班队{
私人：
向量指针；
向量：：迭代器；
公众：
void newbunny（）；
空乘（）；
};
void team:：newbunny（）{
Bunny*bun；//指向Bunny类的指针
兔子=新兔子；
cout在对std:：vector进行迭代时，您似乎试图修改它。出于各种原因，这通常不是一个好主意

特别是，当您在迭代器的循环中调用
newbunny（）
时，您用来保持的迭代器可能会无效，因为在
推回过程中向量可能会被调整大小

有关详细信息，请参阅。
在对std:：vector进行迭代时，您似乎正在尝试修改它。出于各种原因，这通常不是一个好主意

特别是，当您在迭代器的循环中调用
newbunny（）
时，您用来保持的迭代器可能会无效，因为在
推回过程中向量可能会被调整大小

有关详细信息，请参阅。
在对std:：vector进行迭代时，您似乎正在尝试修改它。出于各种原因，这通常不是一个好主意

特别是，当您在迭代器的循环中调用
newbunny（）
时，您用来保持的迭代器可能会无效，因为在
推回过程中向量可能会被调整大小

有关详细信息，请参阅。
在对std:：vector进行迭代时，您似乎正在尝试修改它。出于各种原因，这通常不是一个好主意

特别是，当您在迭代器的循环中调用
newbunny（）
时，您用来保持的迭代器可能会无效，因为在
推回过程中向量可能会被调整大小

有关详细信息，请参阅。
如其他人所述，
推回（）
是您的罪魁祸首，而不是新的

缓和的一种方法是：

size_t const max(bunpointer.size());
for(size_t i(0); i < max; ++i)
{
    cout << bunpointer[i]->getname() << " gave a birth. ";
    newbunny();
}

size_t const max（bunpointer.size（））；
对于（尺寸i（0）；icout getname（）正如其他人所提到的，
push_back（）
是你的罪魁祸首，而不是新的

缓和的一种方法是：

size_t const max(bunpointer.size());
for(size_t i(0); i < max; ++i)
{
    cout << bunpointer[i]->getname() << " gave a birth. ";
    newbunny();
}

size_t const max（bunpointer.size（））；
对于（尺寸i（0）；icout getname（）正如其他人所提到的，
push_back（）
是你的罪魁祸首，而不是新的

缓和的一种方法是：

size_t const max(bunpointer.size());
for(size_t i(0); i < max; ++i)
{
    cout << bunpointer[i]->getname() << " gave a birth. ";
    newbunny();
}

size_t const max（bunpointer.size（））；
对于（尺寸i（0）；icout getname（）正如其他人所提到的，
push_back（）
是你的罪魁祸首，而不是新的

缓和的一种方法是：

size_t const max(bunpointer.size());
for(size_t i(0); i < max; ++i)
{
    cout << bunpointer[i]->getname() << " gave a birth. ";
    newbunny();
}

size_t const max（bunpointer.size（））；
对于（尺寸i（0）；inew
。代码变得更简单，并且没有内存泄漏的机会。此外，我认为在team类中不需要迭代器成员，除非您能证明其原因

2） 至于你眼前的问题，只需要使用一个不依赖迭代器的循环。换句话说，一个简单的循环，从0到当前兔子的数量，减去1

以下是一个例子：

#include <vector>
//...
class Troop {
   private:
       std::vector<Bunny> bunpointer;
   public:
       void newbunny();
       void multiply();
};

void Troop::newbunny() {
   bunpointer.push_back(Bunny());
}

void Troop::multiply() {
    size_t siz = bunpoiner.size(); 
    for (size_t i = 0; i < siz; ++i ) {  
       newbunny();
       cout << (*it)->getname() << " gave a birth. ";
    }
}

#包括
//...
班队{
私人：
std：：向量指针；
公众：
void newbunny（）；
空乘（）；
};
void team:：newbunny（）{
兔子指针。推回（Bunny（））；
}
void：：multiply（）{
size_t siz=bunpoiner.size（）；
对于（size_t i=0；inew
。代码变得更简单，并且没有内存泄漏的机会。此外，我认为在team类中不需要迭代器成员，除非您能证明其原因

2） 至于你眼前的问题，只需要使用一个不依赖迭代器的循环。换句话说，一个简单的循环，从0到当前兔子的数量，减去1

以下是一个例子：

#include <vector>
//...
class Troop {
   private:
       std::vector<Bunny> bunpointer;
   public:
       void newbunny();
       void multiply();
};

void Troop::newbunny() {
   bunpointer.push_back(Bunny());
}

void Troop::multiply() {
    size_t siz = bunpoiner.size(); 
    for (size_t i = 0; i < siz; ++i ) {  
       newbunny();
       cout << (*it)->getname() << " gave a birth. ";
    }
}

#包括
//...
班队{
私人：
std：：向量指针；
公众：
void newbunny（）；
空乘（）；
};
void team:：newbunny（）{
兔子指针。推回（Bunny（））；
}
void：：multiply（）{
size_t siz=bunpoiner.size（）；
对于（size_t i=0；inew
。代码变得更简单，并且没有内存泄漏的机会。此外，我认为在team类中不需要迭代器成员，除非您能证明其原因

2） 至于你眼前的问题，只需要使用一个不依赖迭代器的循环。换句话说，一个简单的循环，从0到当前兔子的数量，减去1

以下是一个例子：

#include <vector>
//...
class Troop {
   private:
       std::vector<Bunny> bunpointer;
   public:
       void newbunny();
       void multiply();
};

void Troop::newbunny() {
   bunpointer.push_back(Bunny());
}

void Troop::multiply() {
    size_t siz = bunpoiner.size(); 
    for (size_t i = 0; i < siz; ++i ) {  
       newbunny();
       cout << (*it)->getname() << " gave a birth. ";
    }
}

#包括
//...
班队{
私人：
std：：向量指针；
公众：
void newbunny（）；
空乘（）；
};
void team:：newbunny（）{
兔子指针。推回（Bunny（））；
}
void：：multiply（）{
size_t siz=bunpoiner.size（）；
对于（size_t i=0；i