我正在编写一个搜索T型电梯的程序。 https://youtu.be/F3rhyJqusE4
但是我在处理spin_env变量时遇到问题，该变量的定义如下：
struct spin_environment {
vector< pair<int, int> > AND;
vector< vector <pair<int, int> > > OR;
};
spin_environment spin_env[4][2][5];
特别是spin_env[1][1][2].AND在回溯期间已损坏。初始化时，其大小为 1 。但是在回溯过程中，它的大小突然达到了 536870911 ，并且找不到其中所有内容的地址。但是spin_env中的其他任何内容（例如spin_env[3][0][1].AND）都没有改变。
所以我认为这应该是内存问题，因此我将堆的保留内存量设置为1GB，堆栈将200MB设置为保留值（默认均为1MB）。但是发生了同样的问题，即使我拍摄了内存快照，使用的内存数量也没有变化。
我想知道为什么会发生此错误以及如何解决它。请帮忙！我使用的IDE是在x86调试模式下构建的Visual Studio C ++ 2017。
完整代码如下所述（抱歉，请注意一点点）
#include<stdio.h>
#include<stdlib.h>
#include<utility>
#include<vector>
using namespace std;
vector<pair<int, int>> offset[4][2] = {
{ { { -1, 0 },{ -1, 1 } },{ { 1, 0 },{ 1, 1 } } },
{ { { 1, 0 },{ 0, 2 },{ 0, 2 },{ 1, 2 },{ 1,2 } },{ { 1, 0 },{ 0, 2 },{ 1, 2 } } },
{ { { 1, 0 } },{ { -1, 0 } } },
{ { { -1, 0 },{ 0, 2 },{ -1,2 } },{ { -1, 0 },{ 0, 2 },{ 0, 2 },{ -1,2 },{ -1,2 } } }
};
pair<int, int> block[4][4] = {
{ { 0, 0 },{ 1, 0 },{ -1, 0 },{ 0, 1 } },
{ { 0, 0 },{ 1, 0 },{ 0, -1 },{ 0, 1 } },
{ { 0, 0 },{ 1, 0 },{ -1, 0 },{ 0, -1 } },
{ { 0, 0 },{ 0, -1 },{ -1, 0 },{ 0, 1 } }
};
struct spin_environment {
vector< pair<int, int> > AND;
vector< vector <pair<int, int> > > OR;
};
spin_environment spin_env[4][2][5];
vector<int> state_order = { 0, 1, 2, 1, 0}, spin_order = { 0, 0, 0, 0 };
vector<vector<int>> answer;
int field[10][20];
pair<int, int> center = { 5, 18 };
void simulation(int);
pair<int, int> operator+ (pair<int, int> a, pair<int, int> b) {
return { a.first + b.first, a.second + b.second };
}
//initialize spin_env
void initialization() {
spin_env[0][0][0].AND = { { 0, -1 } };
spin_env[0][0][1].AND = { { 0, -1 },{ -1, -1 } };
spin_env[0][1][0].AND = { { 0, -1 } };
spin_env[0][1][1].AND = { { 0, -1 },{ 1, -1 } };
spin_env[1][0][0].AND = { { -1, 0 } };
spin_env[1][0][1].AND = { { -1, 0 },{ 1, -1 } };
spin_env[1][0][2].AND = { { -1, 0 },{ 2,0 } };
spin_env[1][0][2].OR = { { { 1, -1 },{ 2, -1 },{ 1, -2 } } };
spin_env[1][0][3].AND = { { -1, 0 },{ 1, -1 },{ -1, 2 } };
spin_env[1][0][4].AND = { { -1, 0 },{ 2,0 },{ -1, 2 } };
spin_env[1][0][4].OR = { { { 1, -1 },{ 2, -1 },{ 1, -2 } } };
spin_env[1][1][0].AND = { { -1, 0 } };
spin_env[1][1][1].AND = { { -1, 0 } };
spin_env[1][1][1].OR = { { { 1, -1 },{ 2, -1 } },{ { 2, 0 },{ 1, 1 } } };
spin_env[1][1][2].AND = { { -1, 0 } };
spin_env[1][1][2].OR = { { { 1, -1 },{ 2, -1 } },{ { 2, 0 },{ 1, 1 } },{ { -1, 2 },{ 0, 3 } } };
spin_env[2][0][0].AND = { { 0, 1 } };
spin_env[2][1][0].AND = { { 0, 1 } };
spin_env[3][0][0].AND = { { 1, 0 } };
spin_env[3][0][1].AND = { { 1, 0 } };
spin_env[3][0][1].OR = { { { -1, -1 },{ -2, -1 } },{ { -2, 0 },{ -1, 1 } } };
spin_env[3][0][2].AND = { { 1, 0 } };
spin_env[3][0][2].OR = { { { -1, -1 },{ -2, -1 } },{ { -2, 0 },{ -1, 1 } },{ { 1, 2 },{ 0, 3 } } };
spin_env[3][1][0].AND = { { 1, 0 } };
spin_env[3][1][1].AND = { { 1, 0 },{ -1, -1 } };
spin_env[3][1][2].AND = { { 1, 0 },{ -2,0 } };
spin_env[3][1][2].OR = { { { -1, -1 },{ -2, -1 },{ -1, -2 } } };
spin_env[3][1][3].AND = { { 1, 0 },{ -1, -1 },{ 1, 2 } };
spin_env[3][1][4].AND = { { 1, 0 },{ -2,0 },{ 1, 2 } };
spin_env[3][1][4].OR = { { { -1, -1 },{ -2, -1 },{ -1, -2 } } };
}
//subroutine function of simulation()
void subroutine(int index, int s, int c, int t, int sub_index) {
if (sub_index == spin_env[s][c][t].OR.size()) {
center.first += offset[s][c][t].first;
center.second -= offset[s][c][t].second;
simulation(index + 1);
center.first -= offset[s][c][t].first;
center.second += offset[s][c][t].second;
return;
}
int pass = 0;
for (int i = 0; i < spin_env[s][c][t].OR[sub_index].size(); i++) {
pair<int, int> temp = spin_env[s][c][t].OR[sub_index][i];
if (field[center.second - temp.second][center.first + temp.first] == 1)
{
pass = 1;
break;
}
}
if (pass) {
subroutine(index, s, c, t, sub_index + 1);
return;
}
for (int i = 0; i < spin_env[s][c][t].OR[sub_index].size(); i++) {
pair<int, int> temp = spin_env[s][c][t].OR[sub_index][i];
if (field[center.second - temp.second][center.first + temp.first] == -1)
continue;
field[center.second - temp.second][center.first + temp.first] = 1;
subroutine(index, s, c, t, sub_index + 1);
field[center.second - temp.second][center.first + temp.first] = 0;
}
}
//recursive function for backtracking
void simulation(int index) {
if (index == spin_order.size()) {
for (int y = 0; y < 10; y++) {
for (int x = 0; x < 20; x++) {
switch (field[y][x]) {
case 1:
printf("1 ");
break;
case -1:
printf("X ");
break;
default:
printf(" ");
break;
}
}
printf("\n");
}
return;
}
int s, c, t;
pair<int, int> temp;
s = state_order[index];
t = spin_order[index];
switch (state_order[index + 1] - s) {
case 1:
case -3:
c = 0;
break;
case -1:
case 3:
c = 1;
break;
}
for (int j = 0; j < spin_env[s][c][t].AND.size(); j++) {
temp = spin_env[s][c][t].AND[j];
if (field[center.second - temp.second][center.first + temp.first] == -1)
{
return;
}
}
for (int j = 0; j < 4; j++) {
temp = block[state_order[index + 1]][j] + offset[s][c][t];
if (field[center.second - temp.second][center.first + temp.first] == 1)
{
return;
}
}
for (int j = 0; j < spin_env[s][c][t].AND.size(); j++) {
temp = spin_env[s][c][t].AND[j];
field[center.second - temp.second][center.first + temp.first] = 1;
}
for (int j = 0; j < 4; j++) {
temp = block[state_order[index + 1]][j] + offset[s][c][t];
field[center.second - temp.second][center.first + temp.first] = -1;
}
subroutine(index, s, c, t, 0);
for (int j = 0; j < spin_env[s][c][t].AND.size(); j++) {
temp = spin_env[s][c][t].AND[j];
field[center.second - temp.second][center.first + temp.first] = 0;
}
for (int j = 0; j < 4; j++) {
temp = block[state_order[index + 1]][j] + offset[s][c][t];
field[center.second - temp.second][center.first + temp.first] = 0;
}
}
//recursive fuction for generate permutation
void permutation(int index) {
if (index == spin_order.size()) {
for (int j = 0; j < 4; j++) {
pair<int, int> temp = block[state_order[0]][j];
field[center.second - temp.second][center.first + temp.first] = -1;
}
simulation(0);
for (int j = 0; j < 4; j++) {
pair<int, int> temp = block[state_order[0]][j];
field[center.second - temp.second][center.first + temp.first] = 0;
}
return;
}
int k;
switch (state_order[index]) {
case 0:
k = 2;
break;
case 1:
if (state_order[index + 1] == 2) k = 5;
else k = 3;
break;
case 2:
k = 1;
break;
case 3:
if (state_order[index + 1] == 2) k = 5;
else k = 3;
break;
}
for (int i = 0; i < k; i++) {
spin_order[index] = i;
permutation(index + 1);
}
}
int main() {
initialization();
permutation(0);
}
答案 0 :(得分：3)
照原样执行代码，只需将field的声明更改为此即可检测到您超出了field的范围：
std::vector<std::vector<int>> field(10, std::vector<int>(20));
由于您使用的是Visual Studio，并且在调试模式下运行，因此在调试模式下的Visual C ++将检测std::vector的越界错误情况。错误发生在permutation函数中：
if (index == spin_order.size()) {
for (int j = 0; j < 4; j++) {
pair<int, int> temp = block[state_order[0]][j];
field[center.second - temp.second][center.first + temp.first] = -1; // <-- Out of bounds here
运行此程序时，std::pair<int, int>变量center和temp的值如下：
center = {5,18}
temp = {0,0}
center.second - temp.second的值远远超过了最高的行索引，即9，因此您正在访问vector的越界。自从您调用未定义的行为以来，该行之后的所有内容都将成为讨论的重点。
请注意，这是通过将field声明从使用原始数组更改为std::vector来检测到的。由于Visual Studio在调试模式下检查std::vector和std::array的边界条件，因此您应该利用这一点并将所有数组声明为std::vector或std::array，以便您可以轻松地检测到这些错误，或者至少可以验证自己没有超出范围。
此外，vector和array都具有一个at()成员函数，可用于检测边界条件，并散布at()调用而不是使用{{1} }访问元素也是调试应用程序的另一种方法，或者至少验证您没有边界访问问题。
现在如何解决此问题？您需要调试代码，看看为什么[ ]和/或center为您提供了您所期望的值，或者增加了temp向量/数组的大小以容纳索引价值观。