C++ 我想我有内存泄漏？

我正在尝试使用动态阵列进行骑士之旅，因为用户将能够实现他们自己的棋盘大小，以及他们希望骑士在棋盘中的起始位置。 然而，在我将所有内容都更改为动态数组之前，我能够使用静态数组执行我的代码，但是现在每当我的代码执行时，我都会切换到动态数组，我相信内存泄漏会导致程序崩溃。我想知道我的解构器是否工作不正常？或者，如果有其他方法，我必须删除动态数组？ 我还想知道是否有办法让这段代码更高效，更准确地说，让Move（）函数更高效。谢谢

#include <iostream>
#include <iomanip>
#include "stdafx.h"
using namespace std;

class Knight
{
private:
int Tracker = 1;
int BoardSize;
int **Board = new int*[BoardSize];
public:
Knight(int s)
{
    BoardSize = s;
    for (int i = 0; i <= s -1; i++)
    {
        Board[i] = new int[s];
    }
    for (int i = 0; i <= s - 1; i++)
    {
        for (int j = 0; j <= s - 1; j++)
        {
            Board[i][j] = 0;
        }
    }
}
~Knight()
{
    for (int i = 0; i <= BoardSize - 1; i++)
    {
        delete[] Board[i];
    }
    delete[] Board;
}

void MarkUp(int &val)
{
    val = Tracker;
    Tracker++;
}

void MarkDown(int &val)
{
    val = 0;
    Tracker--;
}

bool PossibleMove(int &val)
{
    if (val == 0)
        return 1;
    else
        return 0;
}

void Display()
{
    for (int k = 0; k < (BoardSize * 5) + 1; k++)
    {
        cout << "-";
    }
    cout << endl;
    for (int i = 0; i <= BoardSize - 1; i++)
    {
        cout << "| ";
        for (int j = 0; j <= BoardSize - 1; j++)
        {
            cout << setw(2) << setfill('0') << Board[i][j] << " | ";
        }
        cout << endl;
        for (int k = 0; k < (BoardSize * 5) + 1; k++)
        {
            cout << "-";
        }
        cout << endl;
    }
    cout << endl << endl;
}

bool Move(int x, int y)
{
    if (Tracker > (BoardSize * BoardSize))
    {
        return true;
    }
    if (PossibleMove(Board[x][y])) {
        if ((x - 2 >= 0) && (y + 1 <= (BoardSize - 1)))
        {
            MarkUp(Board[x][y]);
            if (Move(x - 2, y + 1))
            {
                return true;
            }
            else
            {
                MarkDown(Board[x][y]);
            }
        }
        if ((x - 2 >= 0) && (y - 1 >= 0))
        {
            MarkUp(Board[x][y]);
            if (Move(x - 2, y - 1))
            {
                return true;
            }
            else
            {
                MarkDown(Board[x][y]);
            }
        }
        if ((x - 1 >= 0) && (y + 2 <= (BoardSize - 1)))
        {
            MarkUp(Board[x][y]);
            if (Move(x - 1, y + 2))
            {
                return true;
            }
            else
            {
                MarkDown(Board[x][y]);
            }
        }
        if ((x - 1 >= 0) && (y - 2 >= 0))
        {
            MarkUp(Board[x][y]);
            if (Move(x - 1, y - 2))
            {
                return true;
            }
            else
            {
                MarkDown(Board[x][y]);
            }
        }
        if ((x + 2 <= (BoardSize - 1)) && (y + 1 <= (BoardSize - 1)))
        {
            MarkUp(Board[x][y]);
            if (Move(x + 2, y + 1))
            {
                return true;
            }
            else
            {
                MarkDown(Board[x][y]);
            }
        }
        if ((x + 2 <= (BoardSize - 1)) && (y - 1 >= 0))
        {
            MarkUp(Board[x][y]);
            if (Move(x + 2, y - 1))
            {
                return true;
            }
            else
            {
                MarkDown(Board[x][y]);
            }
        }
        if ((x + 1 <= (BoardSize - 1)) && (y + 2 <= (BoardSize - 1)))
        {
            MarkUp(Board[x][y]);
            if (Move(x + 1, y + 2))
            {
                return true;
            }
            else
            {
                MarkDown(Board[x][y]);
            }
        }
        if ((x + 1 <= (BoardSize - 1)) && (y - 2 >= 0))
        {
            MarkUp(Board[x][y]);
            if (Move(x + 1, y - 2))
            {
                return true;
            }
            else
            {
                MarkDown(Board[x][y]);
            }
        }
    }
    return false;
}   
};

int main()
{
int size = 0;
int Row, Col;
int opt = 0;

do
{
    cout << "Welcome to Knights Tour!" << endl;
    cout << "1) Start the Tour." << endl;
    cout << "2) Quit." << endl;
    cin >> opt;

    switch (opt)
    {
    case 1:
    {
        cout << "Enter board size:" << endl;
        cin >> size;

        Knight K1(size);

        cout << "Enter Row:" << endl;
        cin >> Row;
        cout << "Enter Column: " << endl;
        cin >> Col;

        if (K1.Move(Row, Col))
        {
            cout << "\nOperation was Successful." << endl;
            cout << "Possible Solution:" << endl;
            K1.Display();
        }
        else
        {
            cout << "\nThat is not Possible." << endl;
        }
        cout << endl;
        break;
    }
    case 2:
    {
        exit(0);
        break;
    }
    default:
    {
        cout << "Not a Valid Option." << endl;
        cout << "Try Again Please." << endl;
        cout << endl;
        break;
    }
    }
} while (opt != 2);
return 0;
}

#包括
#包括
#包括“stdafx.h”
使用名称空间std；
阶级骑士
{
私人：
int-Tracker=1；
int板尺寸；
int**Board=新int*[BoardSize]；
公众：
奈特（内特s）
{
BoardSize=s；
对于（int i=0；i此代码的工作方式与您认为的不同：

int BoardSize;
int **Board = new int*[BoardSize];

BoardSize的值将是分配给它的内存中发生的任何值，因此
new
将尝试分配一个未知大小的数组

不要为此使用手工编码的动态数组。使用std:：vector就是它的用途。在实际生产代码中，您几乎永远不应该使用动态分配的数组。您将使用一个标准容器。
正如多人评论中指出的，内存泄漏不会导致崩溃（通常）

问题是，在构造函数中，您将值分配给
Board
数组元素。但是，您从不为
Board
数组本身分配内存。也就是说，当您分配
Board[I]=new int[s]；
时，
Board
指向某个随机地址。这是因为行
int**Board=new int*[BoardSize]；
在构造函数启动之前不会执行

因此，以下措施应该有效：

class Knight {
  private:
    int BoardSize;
    int **Board;

  public:
    Knight (int s) {
      BoardSize = s;
      Board = new int*[BoardSize];

      // Remainder of code
    }
};

但是，我真的建议您使用它来代替。这样您就不必处理内存（de）分配问题。这看起来可以像下面这样简洁：

#include <vector>

class Knight {
  private:
    int BoardSize;
    std::vector<std::vector<int>> Board;

  public:
    Knight (int s) : BoardSize(s), Board(s, std::vector<int>(s, 0)) { }
};

#包括
阶级骑士{
私人：
int板尺寸；
矢量板；
公众：
奈特（int-s）：BoardSize（s），Board（s，std:：vector（s，0））{
};

请注意，我在中初始化了类成员目录。
您有valgrind吗？为什么不使用？您的程序在执行多长时间后会崩溃？除非您的系统完全耗尽内存，否则内存泄漏很少会导致崩溃。请分享应用程序失败时收到的错误消息。您认为
BoardSize
是什么当您分配
线路板
？“我认为内存泄漏，程序崩溃”内存泄漏不会导致崩溃。它们只是泄漏内存。std:：vector允许您停止担心内存释放。您仍然需要将线路板调整为
s
列，并将每列调整为
s
行（或者反过来说——我记不得了）。@MartinBonner哦，当然，但你不会“暴露”对于分配，你只需告诉vector你希望它包含多少元素。谢谢Darhuuk修复了它。虽然我不明白为什么我不能像最初那样拥有它，因为它本质上还做着同样的事情吗？@MichaelHeck我扩展了我的答案。现在清楚了吗？是的，Darhuuk解释了很多。谢谢非常感谢。