c++ - g++ : array bound is not an integer constant before ‘]’ token

Question

当我尝试编译代码时，g++ 遇到了生成此错误代码的问题:

maze.h:16:29:错误:数组边界不是“]”标记之前的整数常量
bool canMove(int m[mazeSize][mazeSize], int r, int c);

现在，我已经对此错误进行了一些研究，这似乎是由于编译时不知道数组大小造成的。我尝试使数组保持不变，但这最终会导致更多错误，因为稍后在代码中重新分配数组并产生此错误:

maze.cpp:在成员函数‘int Maze::startMazeGen()’中:
maze.cpp:185:15:错误:分配只读位置“maze[i][j]”
迷宫[i][j] = 1;
^

我还看到人们提到使用 vector 会更容易，但我在尝试重新调整代码以使用 vector 而不是数组时也遇到了问题。

这是我的其余代码:

运动.h

#pragma once
#include <iostream>
#include <curses.h>
#ifndef MOVEMENT_H
#define MOVEMENT_H
class Movement
{
    public:
        static const int playerX = 2; // sets player starting position
        static const int playerY = 2;
};
#endif

运动.cpp

#include <iostream>
#include <curses.h>
#include <ctime>
#include "maze.h"
//#include "movement.h"

bool running = true;
int playerX = 2;
int playerY = 2;


//Maze::maze Maze::mazeGen;
//int Maze::mazeGen.Maze::maze::generateMaze::maze(int m[Maze::mazeSize]
[Maze::mazeSize], int r, int c);

// Detect Char input
// and move player in direction
void getUserInput()
{
    char userInput = getch();
    if (userInput == 'w') {
        int playerY2 = playerY - 1;
        if (Maze::maze[playerY2][playerX] == ' ') {
            Maze::maze[playerY][playerX] = ' ';
            playerY--;
            Maze::maze[playerY][playerX] = 'x';
    }
}
    if (userInput == 'a') {
        int playerX2 = playerX - 1;
        if (Maze::maze[playerY][playerX2] == ' ') {
            Maze::maze[playerY][playerX] = ' ';
            playerX--;
            Maze::maze[playerY][playerX] = 'x';
    }
}
    if (userInput == 's') {
        int playerY2 = playerY + 1;
        if (Maze::maze[playerY2][playerX] == ' ') {
            Maze::maze[playerY][playerX] = ' ';
            playerY++;
            Maze::maze[playerY][playerX] = 'x';
    }
}
    if (userInput == 'd') {
        int playerX2 = playerX + 1;
        if (Maze::maze[playerY][playerX2] == ' ') {
            Maze::maze[playerY][playerX] = ' ';
            playerX++;
            Maze::maze[playerY][playerX] = 'x';
        }
    }
}

// Main game update
// Runs through all functions required
void update()
{
    getUserInput();
    clear();
    Maze::generateMaze;
    refresh();
}


//
//
/*int main()
{
    // Initate nCurses display
    initscr();
    while (true) {
    update();
}
// End nCurses display
endwin();
return 0;
}*/

迷宫.h

#pragma once
// MAZE.h
#include <iostream>
#include <ctime>
#ifndef MAZE_H
#define MAZE_H
extern int r;
extern int c;
extern int mazeSize; //number can be changed to make some big sweaty mazes making it an even number makes it act a bit weird sometimes so its better to use an odd number
extern int maze[mazeSize][mazeSize];
class Maze
{
    public:
        int blockedSquare = 1;
        void move(int m[mazeSize][mazeSize], int &r, int &c);
        bool canMove(int m[mazeSize][mazeSize], int r, int c);
        void solve(int m[mazeSize][mazeSize], int &r, int &c);
        bool canSolve(int m[mazeSize][mazeSize], int r, int c);
        void generateMaze(int m[mazeSize][mazeSize], int r, int c);
        int findStart();
        void printMaze(int m[mazeSize][mazeSize]);
        int startMazeGen();
};
#endif

迷宫.cpp

#include <iostream>
#include <ctime>
#include <vector>
#include "maze.h"
bool foundExit = false;
int mazeSize = 31;
int maze[mazeSize][mazeSize] = { 0 };
void Maze::generateMaze(int const m[mazeSize][mazeSize], int r, int c)
{

    bool made = false;

    while (made == false)
    {
        if (c == mazeSize - 1)
            foundExit = true;


        if (canSolve(m, r, c))
        {
            solve(m, r, c);
        }
        else if (canMove(m, r, c))
        {
            m[r][c] = 2; //2 means you can't move from that square, setting any lower stops maze from being made
            move(m, r, c); //move to first open space that can be found
        }
        else
            made = true;

    }

}


void Maze::move(int m[mazeSize][mazeSize], int &r, int &c)
{
    if (m[r][c + 1] == 0)
        c++;
    else if (m[r + 1][c] == 0)
        r++;
    else if (m[r][c - 1] == 0)
        c--;
    else if (m[r - 1][c] == 0)
        r--;
    else
        generateMaze(maze, r, c); //if maze cant be solved it generates a new one so the player doesnt have something that is impossible to solve

}

bool Maze::canMove(int m[mazeSize][mazeSize], int r, int c) //if there is an adjacent zero space, return true
{
    if (m[r][c + 1] == 0)
        return true;
    else if (m[r + 1][c] == 0)
        return true;
    else if (m[r][c - 1] == 0)
        return true;
    else if (m[r - 1][c] == 0)
        return true;
    else
        return false;
}

void Maze::solve(int m[mazeSize][mazeSize], int &r, int &c) //solves maze through with dijkstras algorithmto ensure it can be solved
{
    bool foundSolution = false;

    while (foundSolution == false)
    {

        int direction = (1 + rand() % 4) * 3;

        switch (direction)
        {
        case 3:
            if (c + 1 <= mazeSize - 1 && m[r][c + 2] == blockedSquare && m[r - 1][c + 1] == blockedSquare && m[r + 1][c + 1] == blockedSquare && m[r][c + 1] == blockedSquare)
            {
                if (c == mazeSize - 2 && foundExit == true)
                    ; //do nothing
                else
                {
                    c++;
                    foundSolution = true;
                }
            }
            break;
        case 6:
            if (r + 1 <= mazeSize - 2 && m[r + 2][c] == blockedSquare && m[r + 1][c + 1] == blockedSquare && m[r + 1][c - 1] == blockedSquare && m[r + 1][c] == blockedSquare && c != 0 && c != mazeSize - 1)
            {
                r++;
                foundSolution = true;
            }
            break;
        case 9:
            if (c - 1 >= 0 && m[r][c - 2] == blockedSquare && m[r - 1][c - 1] == blockedSquare && m[r + 1][c - 1] == blockedSquare && m[r][c - 1] == blockedSquare && c - 1 != 0)
            {
                c--;
                foundSolution = true;
            }
            break;
        case 12:
            if (r - 1 >= 1 && m[r - 2][c] == blockedSquare && m[r - 1][c + 1] == blockedSquare && m[r - 1][c - 1] == blockedSquare && m[r - 1][c] == blockedSquare && c != 0 && c != mazeSize - 1)
            {
                r--;
                foundSolution = true;
            }
            break;
        }
    }

    m[r][c] = 0;
}



bool Maze::canSolve(int m[mazeSize][mazeSize], int r, int c) //if an adjacent square can be moved to, return true
{
    bool solvable = false;

    if (r <= mazeSize - 3 && m[r + 2][c] == blockedSquare && m[r + 1][c + 1] == blockedSquare && m[r + 1][c - 1] == blockedSquare && m[r + 1][c] == blockedSquare && c != 0 && c != mazeSize - 1) //if adjacent space can be moved to 
    {
        solvable = true;
    }
    else if (c <= mazeSize - 2 && m[r][c + 2] == blockedSquare && m[r - 1][c + 1] == blockedSquare && m[r + 1][c + 1] == blockedSquare && m[r][c + 1] == blockedSquare)
    {
        if (c == mazeSize - 2 && foundExit == true)
            ; //do nothing
        else
        {
            solvable = true;
        }
    }
    else if (r >= 2 && m[r - 2][c] == blockedSquare && m[r - 1][c + 1] == blockedSquare && m[r - 1][c - 1] == blockedSquare && m[r - 1][c] == blockedSquare && c != 0 && c != mazeSize - 1) //if not on extreme left or right
    {
        solvable = true;
    }
    else if (c >= 1 && m[r][c - 2] == blockedSquare && m[r - 1][c - 1] == blockedSquare && m[r + 1][c - 1] == blockedSquare && m[r][c - 1] == blockedSquare && c - 1 != 0)
    {
        solvable = true;
    }

    return solvable;
}

int Maze::findStart()
{
    return 1 + rand() % (mazeSize - 2);
}

void Maze::printMaze(int m[mazeSize][mazeSize])
{

    std::cout << std::endl;

    for (int i = 0; i < mazeSize; ++i) {
        for (int j = 0; j < mazeSize; ++j)
        {
            switch (m[i][j])
            {
            case 0:
                std::cout << "  ";
                break;
            case 1:
                std::cout << "▓▓";
                break;
            case 2:
                std::cout << "  ";
                break;
            case 3:
                std::cout << "  ";
                break;
            }
        }
        std::cout << std::endl;
    }
}

int Maze::startMazeGen()
{
    srand(time(0));

    for (int i = 0; i < mazeSize; ++i)
        for (int j = 0; j < mazeSize; ++j)
            maze[i][j] = 1;

    int r = findStart();
    //int r = 0;
    int c = 0;

    maze[r][c] = 0;

    generateMaze(maze, r, c);
    maze[r][c] = 2;
    printMaze(maze);
    std::cout << "Press enter to continue ...";
    std::cin.get();
}

这段代码的目的是随机生成一个迷宫，解决它，如果可以解决，则将其打印到屏幕上。如果迷宫无法解决，它会不断生成一个新迷宫，直到可以解决为止。我的目标是通过移动代码来实现这一点，以便用户可以在迷宫中导航。

对于此问题的任何帮助，我们表示赞赏。谢谢!

Answer 1

“现在，我已经对这个错误做了一些研究，这似乎是由于编译时不知道数组大小引起的。我尝试使数组常量，但这最终导致了更多错误，如稍后在代码中重新分配数组”

你在这里混淆了两个东西，数组和数组大小。

数组大小应该是编译时常量。由于您要分配给数组，因此数组元素根本不应该是 const。

const int arrSize = 3;
int arr[arrSize][arrSize];