Сотовый автомат, C ++, проблемы с применением правил

Похоже, это алгоритм или симуляция в Game-of-Life, где пользователь может определить ширину игрового поля и какие правила активны для изучения результатов в течение нескольких поколений.

Игровое поле представляет собой массив [width], инициализированный в «~» (пустой?) С одним «X» (активным) в width / 2, Правила в ruleSet будут действовать на этот массив для создания следующего поколения после одного шага симуляции.

Во-первых, вы явно не запускали этот код и редактировали его для этого сайта, см. Строку № 13:

    for(int i=0; i< width; i ++){

char left = parentArray[i-1]; // <-- What will happen for i == 0?
char middle = parentArray[i];
char right = parentArray[i+1];
...
}

У вас, вероятно, есть какое-то особое условие для обработки i == 0, наверное

if (i == 0)
left = '~';

Так что я приму это.

Во-вторых, вы опечатали правило № 1 вокруг строки № 84:

else if (left == '~' && middle == '~' && middle == 'x'){ // <-- small Latin x

Я не уверен, что должно произойти, так как все правила, кроме правила № 0, представляют собой один и тот же код, и все правила делают то же самое. Таким образом, вы не должны были включать так много кода в свой оригинальный пост.

Во всяком случае, глядя на любое правило:

childArray[i] = ruleSet[0]; // this line in ruleSet[0] only
if(ruleSet[0] == 1){
childArray[i] = 'X';
} else {
childArray[i] = '~';
}
childArray[i] = ruleSet[0]; // overwrite childArray[i]

Ваши массивы представляют собой последовательности ‘X’ и ‘~’ — но вы храните целые числа 0 и 1, которые будут символами ‘\ x00’ и ‘\ x01’ соответственно после того, как вы закончите.
Может быть, это было только для отладки, но вы оставили это в? Или, может быть, вы ошиблись?

Так как все условия if соответствуют только комбинациям ‘~’ и ‘X’ (и ‘x’), ваша симуляция остановится после первого шага и всегда даст тот же результат, когда любое правило включено.

Я предлагаю вам улучшить ваши структуры данных, чтобы с ними было легче работать. Правила имеют две модели: search, который будет заменен на replace когда нашел.

typedef struct rule {
char search[3];
char replace[3];

rule(char* searchPattern, char* replacePattern) {

memcpy(&search, searchPattern, sizeof(search));
memcpy(&replace, replacePattern, sizeof(replace));

}
} rule_t;

Игровое поле представляет собой структуру, которая содержит его ширину и фактические данные.
Обычай operator= создает глубокую копию всего поля для нас.

typedef struct field {
size_t width;
char* data;

field(size_t field_width) {

width = field_width;
data = new char[width + 1];
memset(data, '~', width);
data[width] = '\0';
/* catch out of memory exception here */
}

~field() {

width = 0;
delete[] data;

}

field& operator=(const field& rhs) {
/* prevent self-assignment */
if (this == &rhs)
return *this;
this->width = rhs.width;
delete[] data;
this->data = new char[width + 1];
/* catch out of memory exception here */
memcpy(this->data, rhs.data, width + 1);
return *this;

}

} field_t;

Основной алгоритм

for (int generation = 0; generation < numGenerations; generation++) {

myFieldAfter = myFieldBefore; /* deep copy of field */

/* sliding window pointers */
char *windowBefore = myFieldBefore.data;
char *windowAfter = myFieldAfter.data;
/* we have to stop sizeof(rule_t.search) - 1 = 3 - 1 = 2 bytes before end */
for (size_t x = 0; x < myFieldBefore.width - 2; x++) {

/* apply rules hierarchically */
for (auto it = activeRules.begin(); it != activeRules.end(); it++) {

if (!(memcmp(it->search, windowBefore, sizeof(it->search)))) {
memcpy(windowAfter, it->replace, sizeof(it->replace));
break; /* only apply first matching rule */
}

}

/* move windows */
windowBefore++;
windowAfter++;

}

std::cout << "Generation " << generation << ": " << myFieldBefore.data << "\n";
myFieldBefore = myFieldAfter; /* deep copy back */

}

Я предлагаю вам разобрать аргументы из командной строки, например, вызов может выглядеть myCellAutomaton 32 5 "1,3" чтобы получить поле шириной 32, смоделируйте 5 поколений и используйте правила № 1 и № 3.
Посмотрите на Boost.Program_options. Примерный набросок финальной программы выглядит так:

#include <iostream>
#include <string>
#include <cstring>
#include <vector>

/* definitions from above */

int main(int argc, char** argv) {

int numGenerations;
int width;
std::vector<rule_t> activeRules;

/* parse command line arguments */
numGenerations = 5;
width = 32;

/* example rule */
rule_t myRule("X~~", "XX~");
/* vector of active rules */
activeRules.push_back(myRule);

field_t myFieldBefore(width);
myFieldBefore.data[width / 2] = 'X';
field_t myFieldAfter(width);

/* algorithm here */

}

Вывод следующий:

Generation 0: ~~~~~~~~~~~~~~~~X~~~~~~~~~~~~~~~
Generation 1: ~~~~~~~~~~~~~~~~XX~~~~~~~~~~~~~~
Generation 2: ~~~~~~~~~~~~~~~~XXX~~~~~~~~~~~~~
Generation 3: ~~~~~~~~~~~~~~~~XXXX~~~~~~~~~~~~
Generation 4: ~~~~~~~~~~~~~~~~XXXXX~~~~~~~~~~~

Я надеюсь, что этот ответ дал вам общее представление о том, что делать. Я использовал простые структуры и стандартные вызовы, чтобы сделать его простым, хотя это делает всю программу скорее C-ish, чем чистым C ++.