Question

编辑：问题通过索引迭代并将向量作为参考传递给函数来解决。

我正在创建一个类似细胞自动机的程序。有两个类 - 蚂蚁和doodlebugs。蚂蚁由char'O'表示，doodlebugs由char'X'表示。 2D char数组上的空格是'。'

随着时间的推移，随着对象数量的增加和减少，我有一个动态向量来保存指向对象的指针。

我正在测试我的Ant类。经过三个运动步骤，蚂蚁繁殖。这两个函数都有用，所以我正在测试最后一个Ant函数 - 死亡。

我正在测试一个初始函数来杀死一只蚂蚁（简单地将它从一个字母翻转到数组中的'。'）但它似乎并没有迭代我的整个蚂蚁矢量。如果我没有蚂蚁的品种，它会按预期工作。

例如，我从6蚂蚁开始。我让他们四处走动，然后全部杀死他们。它有效。

我从6只蚂蚁开始，让它们移动3次，繁殖，然后尝试全部杀死它们。只有一些对象“死”（实际上转向'。'）

我假设问题是繁殖函数 - 是关于我如何添加一个干扰迭代的新对象？

以下是相关的代码：

class Ant : public Organism {
    Ant(char array[][20]) {
            this->x = rand() % 20;
            this->y = rand() % 20;
            array[x][y] = 'O';
            this->count = 0;
    }
    Ant(char array[][20], int itsX, int itsY) {
            this->x = itsX;
            this->y = itsY;
            array[x][y] = 'O';
            this->count = 0;
    }

    // If adjacent cell = '.', push back a new Ant object
    void breed(char array[][20], std::vector<Ant*> colony) {
            if (this->count == 2) {
                    if(!occupied_down(array)) { 
                            Ant* temp = new Ant(array, x+1, y);
                            colony.push_back(temp);
                    } else if(!occupied_up(array)) {
                            Ant* temp = new Ant(array, x-1, y);
                            colony.push_back(temp);
                    } else if(!occupied_right(array)) {
                            Ant* temp = new Ant(array, x, y+1);
                            colony.push_back(temp);
                    } else if(!occupied_left(array)) {
                            Ant* temp = new Ant(array, x, y-1);
                            colony.push_back(temp);
                    }
                    this->count = 0;
            }

    }
    void die(char array[][20]) {
            array[this->x][this->y] = '.';
    }
};

 void moveAnts(char step[][20], std::vector<Ant*> colony) {

    std::vector<Ant*>::iterator itr;
    for(itr = colony.begin(); itr < colony.end(); ++itr) {
            Ant* temp = *itr;
            temp->move(step);
    }
 }

void breedAnts(char step[][20], std::vector<Ant*> colony) {

    std::vector<Ant*>::iterator itr;
    for(itr = colony.begin(); itr < colony.end(); ++itr) {
           Ant* temp = *itr;
           temp->breed(step, colony);
   }
 }

void killAnts(char step[][20], std::vector<Ant*> colony) {

    std::vector<Ant*>::iterator itr;
    for(itr = colony.begin(); itr < colony.end(); ++itr) {
            Ant* temp = *itr;
            temp->die(step);
    }
 }

 int main() {

    srand(time(NULL));

    char step[20][20];

    for(int i = 0; i < 20; i++) {
            for(int j = 0; j < 20; j++) {
                    step[i][j] = '.';
            }
    }

    std::vector<Ant*> colony;

    for(int i = 0; i < 6; i++) {
            Ant* test = new Ant(step);
            colony.push_back(test);
    }

    for(int i = 0; i < 4; i++) {
            print(step);
            moveAnts(step, colony);
            breedAnts(step, colony);
    }

    killAnts(step, colony);

    print(step);

    return 0;
 }

Answer 1

更改函数以参考向量。你似乎按价值传递它们。例如。改变

void moveAnts(char step[][20], std::vector<Ant*> colony)

到

void moveAnts(char step[][20], std::vector<Ant*>& colony)

矢量迭代器不循环遍历整个矢量

1 个答案: