C++ g++；：数组绑定在‘；]之前不是整数常量’；代币

当我试图编译代码时，g++生成此错误代码时遇到问题：

maze.h:16:29:错误：数组绑定在']'标记之前不是整数常量
布尔可以移动（intm[mazeSize][mazeSize]，intr，intc）

现在，我已经对这个错误做了一些研究，它似乎是由编译时不知道数组大小引起的。我已尝试将数组设置为常量，但这最终会导致更多错误，因为稍后在代码中重新分配数组并产生此错误：

maze.cpp:在成员函数“int maze:：startMazeGen（）”中：
maze.cpp:185:15:错误：分配只读位置“maze[i][j]”
迷宫[i][j]=1；
^

我还看到有人提到使用向量会更容易，但我也遇到了一些问题，即尝试重新调整代码的用途，以使用向量而不是数组

以下是我的其余代码：

运动

#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

#pragma一次
#包括
#包括
#ifndef运动
#定义运动
阶级运动
{
公众：
静态常量int playerX=2；//设置玩家的起始位置
静态常数int playerY=2；
};
#恩迪夫

movement.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;
}*/

#包括
#包括
#包括
#包括“maze.h”
//#包括“movement.h”
bool running=true；
int playerX=2；
int playerY=2；
//梅兹：梅兹：梅泽根；
//intmaze:：mazeGen.Maze:：Maze:：generateMaze:：Maze（intm[Maze:：mazeSize]
[Maze:：mazeSize]，int r，int c）；
//检测字符输入
//并将玩家移向另一个方向
void getUserInput（）
{
char userInput=getch（）；
如果（userInput='w'）{
int playerY2=playerY-1；
如果（迷宫：：迷宫[player2][playerX]=''）{
迷宫：迷宫[playerY][playerX]=''；
游戏——；
迷宫：迷宫[playerY][playerX]='x'；
}
}
如果（userInput='a'）{
int playerX2=playerX-1；
如果（Maze:：Maze[playerY][playerX2]=''）{
迷宫：迷宫[playerY][playerX]=''；
playerX--；
迷宫：迷宫[playerY][playerX]='x'；
}
}
如果（userInput='s'）{
int playerY2=playerY+1；
如果（迷宫：：迷宫[player2][playerX]=''）{
迷宫：迷宫[playerY][playerX]=''；
playerY++；
迷宫：迷宫[playerY][playerX]='x'；
}
}
如果（userInput='d'）{
int playerX2=playerX+1；
如果（Maze:：Maze[playerY][playerX2]=''）{
迷宫：迷宫[playerY][playerX]=''；
playerX++；
迷宫：迷宫[playerY][playerX]='x'；
}
}
}
//主要游戏更新
//运行所需的所有功能
无效更新（）
{
getUserInput（）；
清除（）；
迷宫：生成码；
刷新（）；
}
//
//
/*int main（）
{
//初始化nCurses显示
initscr（）；
while（true）{
更新（）；
}
//尾端显示
endwin（）；
返回0；
}*/

梅兹

#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

#pragma一次
//梅兹
#包括
#包括
#ifndef迷宫
#定义迷宫
外部-内部r；
外部内部c；
外部-内部mazeSize//数字可以改变，使一些大汗淋漓的迷宫，使其成为偶数，使其行为有时有点怪异，所以最好使用奇数
外部内部迷宫[mazeSize][mazeSize]；
班级迷宫
{
公众：
int blockedSquare=1；
无效移动（int m[mazeSize][mazeSize]，int&r，int&c）；
布尔可以移动（intm[mazeSize][mazeSize]，intr，intc）；
无效解算（int m[mazeSize][mazeSize]，int&r，int&c）；
布尔可解（intm[mazeSize][mazeSize]，intr，intc）；
无效生成码（intm[mazeSize][mazeSize]，intr，intc）；
int findStart（）；
void printMaze（int m[mazeSize][mazeSize]）；
int startMazeGen（）；
};
#恩迪夫

maze.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();
}

#包括
#包括
#包括
#包括“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）
{
布尔制造=假；
while（make==false）
{
如果（c==mazeSize-1）
foundExit=true；
if（canSolve（m，r，c））
{
求解（m，r，c）；
}
else if（可以移动（m，r，c））
{
m[r][c]=2；//2意味着你不能从那个正方形移动，设置任何较低的停止点
移动（m，r，c）；//移动到可以找到的第一个开放空间
}
其他的
制造=真实；
}
}
虚空迷宫：：移动（intm[mazeSize][mazeSize]，int&r，int&c）
{
如果（m[r][c+1]==0）
C++；
如果（m[r+1][c]==0）
r++；
else如果（m[r][c-1]==0）
c--；
else如果（m[r-1][c]==0）
r--；
其他的
generateMaze（迷宫，r，c）；//如果迷宫无法解决，它会生成一个新的迷宫，这样玩家就不会有无法解决的问题
}
boolmaze:：canMove（int m[mazeSize][mazeSize]，int r，int c）//如果存在相邻的零空间，则返回true
{
如果（m[r][c+1]==0）
返回true；
如果（m[r+1][c]==0）
返回true；
else如果（m[r][c-1]==0）
返回true；
else如果（m[r-1][c]==0）
返回true；
其他的
返回false；
}
void Maze:：solve（int m[mazeSize][mazeSize]，int&r，int&c）//使用dijkstras算法求解迷宫，以确保它能够被求解
{
bool-foundSolution=false；
while（foundSolution==false）
{
整数方向=（1+rand（）%4）*3；
开关（方向）
{
案例3：
如果（c+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；
}
打破
}
}
m[r][c]=0；
}
布尔迷宫：：canSolve（int m[mazeSize][mazeSize]，int r，int c）//如果相邻的正方形可以移动到
const int arrSize = 3;
int arr[arrSize][arrSize];