g++ : array bound nu este o constantă întreagă înainte de simbolul ‘]’ (Programare, C++, Array-Uri, C++14)

deadturkey a intrebat.

Am probleme cu g++ care produce acest cod de eroare când încerc să îmi compilez codul:

maze.h:16:29: error: array bound is not an integer constant before ‘]’ token
bool canMove(int m[mazeSize][mazeSize], int r, int c);

Acum, am făcut deja câteva cercetări despre această eroare și se pare că este cauzată de faptul că dimensiunea array-ului nu este cunoscută la compilare. Am încercat să fac ca array-ul să fie constant, dar acest lucru sfârșește prin a cauza mai multe erori mai târziu, deoarece array-ul este realocat mai târziu în cod și produce această eroare:

maze.cpp: In member function ‘int Maze::startMazeGen()’:
maze.cpp:185:15: error: assignment of read-only location ‘maze[i][j]’
maze[i][j] = 1;
^

Am văzut, de asemenea, oameni care au menționat că ar fi mai ușor să se lucreze cu vectori, dar și eu am probleme cu încercarea de a reface codul pentru a lucra cu vectori în loc de array-uri.

Iată restul codului meu:

movement.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

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

labirint.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

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

Scopul acestui cod este de a genera aleatoriu un labirint, de a-l rezolva și apoi de a-l imprima pe ecran dacă poate fi rezolvat. Dacă labirintul nu poate fi rezolvat, continuă să genereze unul nou până când poate fi rezolvat.Vreau să fac acest lucru să funcționeze cu codul de mișcare, astfel încât utilizatorul să poată naviga prin labirint.

Orice ajutor este apreciat în această problemă. Vă mulțumesc!

Comentarii

  • Dimensiunile array-ului trebuie să fie constante la compilare. Nu puteți avea variabile neconstante ca dimensiune. În cazul în care dimensiunile tablourilor dvs. sunt setate în timpul execuției, atunci trebuie să utilizați std::vector. –  > Por Un programator oarecare.
  • Este mazeSize care trebuie să fie constantă, nu matricea („Am încercat să fac matricea constantă…”). Dacă doriți o matrice de dimensiuni variabile, atunci vă sugerez să folosiți std::vector. –  > Por Richard Critten.
  • De asemenea, rețineți că int m[mazeSize][mazeSize] parametrii funcțiilor nu sunt array-uri. –  > Por user7860670.
  • „Am probleme și cu” nu este nici ea o descriere utilă a problemei. –  > Por Sam Varshavchik.
  • Site-ul dvs. Maze clasă nu reprezintă în niciun fel un labirint; în esență, sunt funcții libere pe care s-a întâmplat să le scrieți în cadrul unei definiții de clasă. Ar trebui să aibă variabile membre și să nu depindă de variabilele globale. Consultați ghidul cărții și citiți despre clase și obiecte. –  > Por molbdnilo.
1 răspunsuri
MSalters

„Acum, am făcut deja câteva cercetări cu privire la această eroare și se pare că este cauzată de faptul că dimensiunea array-ului nu este cunoscută la compilare. Am încercat să fac matricea constantă, dar asta sfârșește prin a cauza mai multe erori mai târziu, deoarece matricea este realocată mai târziu în cod”

Confundați două lucruri aici, array-ul și array-ul. dimensiune.

Dimensiunea array-ului ar trebui să fie o constantă la compilare. Din moment ce atribuiți la array, elementele array-ului nu ar trebui să fie const deloc.

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