C++问题中康威的生命博弈

Question

我有几个问题编码康威的生命游戏在C++。我觉得我有一个好的开始，我只是需要一些方向。首先，当我试图运行程序时，我总是得到一个空白的控制台。而且，我也不确定是否有最好的方式来编码板上没有完整的八个邻居的地方。任何帮助都将不胜感激。

规则：

您将“硬代码”启动配置。用户不必提供不同的启动配置(这只会使程序复杂化)。 建议:寻找稳定的配置。也就是说，寻找不断重复模式的社区。重复中的配置数称为周期。有些配置是固定的，这些配置不需要更改就会继续。一个可能的项目是找到这样的配置。 提示:定义一个名为generation的空函数，它接受我们称为world的向量(按引用调用或使用指针)，其中包含当前(或初始)配置。该功能扫描载体并修改细胞，按照先前列出的规则对细胞进行出生和死亡标记。这包括依次检查每个细胞，要么杀死细胞，让细胞存活，要么细胞是空的，决定细胞是否应该诞生。请注意，如果您的代码在它正在修改的向量中对邻居进行计数，则游戏将无法工作。必须在修改世界向量之前创建它的副本，并且该副本用于计数邻居，而单元格在原始向量中被打开或关闭。 应该有一个函数显示，它接受向量世界，并在屏幕上显示网格。在对生成和显示的调用之间，某种时间延迟是合适的。要做到这一点，您的程序应该生成和显示下一代时，您按返回/输入。您可以自动完成此操作(输入实时延迟，而不是等待用户按下键)，但是程序并不需要自动化。 如果您希望“延迟”网格的显示，而不是等待用户在显示下一个网格之前键入某项内容并按enter键，那么您将需要以某种方式暂停或“睡眠”您的程序。如果您使用的是Microsoft，请执行以下操作： 我们将每个单元定义为有八个相邻单元。单元格的邻接点是直接在上面、下面、右边、左边、对角线在右和左、对角在右和左下面的单元格。在检查边缘上的邻居时要小心；您可以确定边缘单元格是否存在边缘以外的邻居。 如果一个被占领的牢房有零个邻居或一个邻居，它就会孤独地死去。如果一个被占用的牢房有三个以上的邻居，它就会因过度拥挤而死亡。 如果一个空单元正好有三个被占用的相邻单元，就会有一个新的单元来代替空单元。 出生和死亡是瞬间发生的，并发生在世代的变化中。一个细胞因任何原因死亡可能有助于导致出生，但一个新生细胞不能复活一个正在死亡的细胞，一个细胞的死亡也不能通过减少当地人口来阻止另一个细胞的死亡。

到目前为止，我的守则：

/*

Filename: main.cpp
Author:
Version: 20120920
Description:

*/

#include<iostream>
#include<vector>
#include<unistd.h>
#include<cstdlib>

using namespace std;

/*Change the values of your world matrix*/
#define ROWS 21
#define COLS 80

/*Change the values for dead or alive*/
#define DEAD  ' '
#define ALIVE '*'

/*Function Prototype for generation*/
void generation (vector< vector<char> > &world, vector< vector<char> > &world_copy);

/*Function Prototype for display*/
void display(vector< vector<char> >);

int main()
{

    vector< vector<char> > world(ROWS, vector<char>(COLS, DEAD));
    vector< vector<char> > world_copy(ROWS, vector<char>(COLS, DEAD));

    /*Set ALIVE cells*/
    world[1][1] = world[1][2] = world[1][3] = ALIVE;

    while(true);
    {
        /*Clear screen and display world*/
        system("cls");
        display(world);

        /*Wait*/
        usleep(8000);

        /*Update World*/
        generation(world, world_copy);

    }
    return 0;
}

/*Copy the contents of world into world_copy*/
void generation (vector< vector<char> > &world, vector< vector<char> > &world_copy)
{
    int ALIVE_count = 0;

    for (int i = 0; i < ROWS; i++)
    {
        for (int j = 0; j < COLS; j++)
        {
            /*Checks neighbors for life*/
            if(world_copy[i-1][j+1] == ALIVE)
            {
                ALIVE_count++;
            }
            if(world_copy[i][j+1] == ALIVE)
            {
                ALIVE_count++;
            }
            if(world_copy[i+1][j+1] == ALIVE)
            {
                ALIVE_count++;
            }
            if(world_copy[i-1][j] == ALIVE)
            {
                ALIVE_count++;
            }
            if(world_copy[i+1][j] == ALIVE)
            {
                ALIVE_count++;
            }
            if(world_copy[i-1][j-1] == ALIVE)
            {
                ALIVE_count++;
            }
            if(world_copy[i][j-1] == ALIVE)
            {
                ALIVE_count++;
            }
            if(world_copy[i+1][j-1])
            {
                ALIVE_count++;
            }

            /*Rule Section*/
            /*Death by loneliness. 0 or 1 neighbors.*/
            if (world_copy[i][j] == ALIVE && (ALIVE_count == 0 || ALIVE_count == 1))
            {
                world[i][j] = world_copy[i][j];
                world[i][j] == DEAD;
            }
            /*Live to next generation. 2 or 3 neighbors.*/
            else if(world_copy[i][j] == ALIVE && (ALIVE_count == 2 || ALIVE_count == 3))
            {
                world[i][j] = world_copy[i][j];
                world[i][j] == ALIVE;
            }
            /*Death by overcrowding. More than 3 neighbors.*/
            else if (world_copy[i][j] == ALIVE && ALIVE_count > 3)
            {
                world[i][j] = world_copy[i][j];
                world[i][j] == DEAD;
            }
            /*Birth. Exactly 3 neighbors.*/
            else if (world_copy[i][j] == ALIVE && ALIVE_count ==3)
            {
                world[i][j] = world_copy[i][j];
                world[i][j] == ALIVE;
            }
        }
    }
}

/*Display the world*/
void display(vector< vector<char> > &world)
{
    for (int i = 0; i < ROWS; i++)
    {
        for (int j = 0; i < COLS; j++)
        {
            cout << world[i][j];
        }

        cout << endl;
    }
}

更新：

在main的while语句中发现了一个问题。我有过一次；过了一会儿：

while(true);
{
/*Clear screen and display world*/
system("cls");
display(world);

/*Wait*/
Sleep(800);

/*Update World*/
generation(world, world_copy);
} 

我继续并取出它，但现在我得到了一个未定义的引用‘显示在时间循环。

Answer 1

不当回路条件

void display(vector< vector<char> > &world)
{
    for (int i = 0; i < ROWS; i++)
    {
        for (int j = 0; i < COLS; j++)
        {
            cout << world[i][j];
        }

        cout << endl;
    }
}

应：

void display(vector< vector<char> > &world)
{
    for (int i = 0; i < ROWS; i++)
    {
        for (int j = 0; j < COLS; j++)
        {
            cout << world[i][j];
        }

        cout << endl;
    }
}

注意内部FOR循环的条件子句。

不正确的while()循环终止

while(true);

应：

while(true)

不适当的分配操作

此模式在代码中重复多次。第一项任务保持不变。第二件事根本没有完成。它是一个条件表达式的计算。看起来是这样的：

world[i][j] = world_copy[i][j];
world[i][j] == DEAD;

应该应该是这样的(注意，我猜测副本上的是先前的状态。不知道你的意图是什么)：

world_copy[i][j] = world[i][j];
world[i][j] = DEAD;

链接期间未定义的符号显示()

文件顶部的函数的原型是：

void display(vector< vector<char> > );

然而，执行情况如下：

void display(vector< vector<char> >& )

注意第二个引用参数，第一个是by参数。不同的参数列表=不同的签名。第二个可能是您想要的，所以更改原型(第一个)以匹配实现(第二个)。

数组索引超出界限

在您的代码中有几个地方(特别是generation()函数)在分配的向量结束后进行索引。例如,

/*Checks neighbors for life*/
if(world_copy[i-1][j+1] == ALIVE)
{
    ALIVE_count++;
}
if(world_copy[i][j+1] == ALIVE)
{
    ALIVE_count++;
}
if(world_copy[i+1][j+1] == ALIVE)

这些[j+1]和[i+1]索引一旦达到(i==(ROWS-1))或(j==(COLS-1))的条件，就会导致进程错误(如果幸运的话)，因为行和COLS是战场的分配大小。同样，对于[i-1]和[j-1]，当i和j处于循环的开始时(i=0或j=0)

解决这个问题的方法有很多，从逻辑到不检查什么会出现溢出(很容易检测)，到用一个从未被触及过的死区(更复杂，但代码更有趣)为您的字段设置框架。

底线：，您必须学会有效地调试您的程序。如果你认为专业工程师只是说出了正确的代码，那就再想一想。平均来说，我们花了一半的时间(字面上)来调试编写的代码。如果你发现自己花的钱少了一点，那么很有可能你没有给予代码它所要求的尽职调查(坦白地说，这是值得的)。

Answer 2

我不太确定板上没有八个邻居的地方编码的最好方法

你应该把这些当作特例来处理。例如，将i=0代码与可以从i = 1开始的循环分开编码。