C++ 4D动态阵列中的访问冲突读取位置

尝试访问时，程序中出现访问冲突读取位置错误 我的4D动态阵列中的元素

这是我的分配代码

void mazeGen(int**** mazes, int width, int height,stack<SDL_Point> backtracker)
{
    numberOfCalls++;
    //first choose a starting location for the maze
    //starting location must be odd in order to ensure that the generator does not go outside
    //the maze bounds.

    //allocate memory for the mazes
    mazes = new int***[NUMHOR];
    for (int i = 0; i < NUMVER; i++)
    {
        mazes[i] = new int**[NUMVER];
    }
    //allocate memory for the actual mazes
    for (int x = 0; x < NUMHOR; x++)
    {
        for (int y = 0; y < NUMVER; y++)
        {
            mazes[x][y] = initMaze(WIDTH, HEIGHT);
        }
    }
    //mazeGenHelper(maze, height, width, backtracker, start);
    bool leftToRight = true;
    for (int x = 0; x < NUMHOR; x++)
    {
        for (int y = 0; y < NUMVER; y++)
        {
            //generate mazes
            SDL_Point* start = new SDL_Point();
            //genx
            do
            {
                start->x = generateRandomRange(1, width - 1);
            } while (start->x % 2 == 0);
            //gen y
            do
            {
                start->y = generateRandomRange(1, height - 1);
            } while (start->y % 2 == 0);
            //empty stack
            while (!backtracker.empty())
            {
                backtracker.pop();
            }
            mazeGenHelper(mazes[x][y], HEIGHT, WIDTH, backtracker, start);
            //delete start to prevent memory leak
            delete start;
        }
    }
}

这是一个迷宫生成程序，以防你不知道

void mazeGenHelper(int** maze, int height, int width, stack<SDL_Point> backtracker, SDL_Point* point,SDL_Point* endPoint)
{
    numberOfCalls++;
    array<int, 4> directions = shuffleDirections();
    for (int i = 0; i < 4; i++)
    {
        switch (directions[i])
        {
        case 1://up
        {
                  if (point->y - 2 > 0 && maze[point->x][point->y - 2] == 1)
                  {
                      //delete maze walls
                      maze[point->x][point->y - 1] = 0;
                      maze[point->x][point->y - 2] = 0;
                      //add current point to the backtracker
                      SDL_Point newPoint = { point->x, point->y };
                      backtracker.push(newPoint);
                      //move the current point
                      point->y -= 2;
                      mazeGenHelper(maze, height, width, backtracker, point,endPoint);
                  }
        }
        case 2://right
        {
                   if (point->x + 2 <width && maze[point->x+2][point->y] == 1)
                   {
                       //delete maze walls
                       maze[point->x+1][point->y] = 0;
                       maze[point->x+2][point->y] = 0;
                       //add current point to the backtracker
                       SDL_Point newPoint = { point->x, point->y };
                       backtracker.push(newPoint);
                       //move the current point
                       point->x += 2;
                       mazeGenHelper(maze, height, width, backtracker, point,endPoint);
                   }
        }
        case 3://down
        {
                   if (point->y + 2 < height && maze[point->x][point->y + 2] == 1)
                   {
                       //delete maze walls
                       maze[point->x][point->y + 1] = 0;
                       maze[point->x][point->y + 2] = 0;
                       //add current point to the backtracker
                       SDL_Point newPoint = { point->x, point->y };
                       backtracker.push(newPoint);
                       //move the current point
                       point->y += 2;
                       mazeGenHelper(maze, height, width, backtracker, point,endPoint);
                   }
        }
        case 4://left
        {
                  if (point->x - 2 > 0 && maze[point->x - 2][point->y] == 1)
                  {
                      //delete maze walls
                      maze[point->x - 1][point->y] = 0;
                      maze[point->x - 2][point->y] = 0;
                      //add current point to the backtracker
                      SDL_Point newPoint = { point->x, point->y };
                      backtracker.push(newPoint);
                      //move the current point
                      point->x -= 2;
                      mazeGenHelper(maze, height, width, backtracker, point,endPoint);
                  }
        }
        }
    }
    if (backtracker.size() != 0)
    {
        //pop curent element off the stack and recall
        SDL_Point newPoint = backtracker.top();
        endPoint->x = newPoint.x;
        endPoint->x = newPoint.y;
        backtracker.pop();
        mazeGenHelper(maze, height, width, backtracker, &newPoint,endPoint);
    }
    // else the maze must be done
}

这里是我试图访问它

void sdlapp::render()
{
    //clear the screen
    SDL_RenderClear(m_renderer);
    //do render stuff here

    //rect area for 
    SDL_Rect rect = { 0,0, zoomLevel, zoomLevel };

    //render the maze walls
    for (int i = 0; i < WIDTH;i++)
    for (int k = 0; k < HEIGHT; k++)
    {
        switch (maze[i][k])//<- thats where i am trying to access it.
        {
        case 1: // theres a wall
        {
                    rect.x = i * zoomLevel-camera->x;
                    rect.y = k * zoomLevel-camera->y;
                    SDL_RenderCopy(m_renderer, mazeWallTex, NULL, &rect);
        }
            break;
        case 2: //theres a start point
        {
                    rect.x = i * zoomLevel - camera->x;
                    rect.y = k * zoomLevel - camera->y;
                    SDL_RenderCopy(m_renderer, mazeStartTex, NULL, &rect);
        }
        case 3:
        {
                  rect.x = i * zoomLevel - camera->x;
                  rect.y = k * zoomLevel - camera->y;
                  SDL_RenderCopy(m_renderer, mazeEndTex, NULL, &rect);
        }
        }

    }
    //update the screen to the current render
    SDL_RenderPresent(m_renderer);
}

我不希望您通读所有这些代码，但无论如何我都发布了。如果有人知道我做错了什么，你能给我指出正确的方向吗

谢谢你抽出时间 JustinWeq，

---

顺便说一句，我真的不想使用向量，并且可以正确地处理locate me内存，绝对没有内存泄漏。

因为它解决了这个问题，我将把我的评论复制到这里作为一个答案，让“unanswered”列表更清晰一些：

我还没有读完全部代码，但最突出的是： 将int****mazes传递给mazeGen，但函数要做的第一件事是丢弃传入的值，并用新的分配替换它

---

如果您希望这些分配对调用方可见，我假设您是这样做的；目前，内存刚刚泄漏，您需要使用int****和maze。我仍然认为你最好不要用原始的指针，但这不是codereview.SE。

难道你不能避免在迷宫中使用4D数组吗..我使用4D数组是因为我生成的迷宫是分块的，用于优化目的，这样我就可以使迷宫比21^2大，而无需过多的加载时间。好吧，让我给你一个例子，内存可以像[m*n]和[m][n]一样分配，第一个是1D数组，第二个是2D数组，理想情况下，它会使代码比2D更混乱，更难调试…我还没有阅读全部代码，但第一件引人注目的事情是：将int****mazes传递给mazeGen，但函数所做的第一件事是丢弃传入的值，并用新的分配替换它。如果您希望这些分配对调用方可见，我假设您是这样做的；目前，内存刚刚泄漏，您需要使用int****和maze。我仍然认为没有原始指针会更好，但这不是codereview.SE。但有时需要比2D大的数组，而且动态数组已经不可能在MS VS中调试。