Question

我正在写一个扫雷副本，我有一个std::vector<Cell *> minefield。我以这种方式创建其内容：

minefield.resize(cols * rows);
for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols; ++j)
        minefield[j + i * cols] = new Cell(j, i);
}

因此，为避免内存泄漏，我以后需要在主类（delete）析构函数中Cell个对象Game中使用。最好的（最有效的）方法是什么？

是吗

Game::~Game() {
    for (int i = 0; i < minefield.size(); ++i)
        delete minefield[i];
}

或者：

Game::~Game() {
    for (auto it = minefield.begin(); it != minefield.end(); ++it)
        delete *it;
}

或者也许：

Game::~Game() {
    for (auto & m : minefield) // I'm not sure if the '&' should be here
        delete m;
}

？

Answer 1

我很确定您不需要这些动态分配。您可以将单元元素的分配和取消分配委托给std :: vector。

尝试创建一个雷区类，该类是分配有std::vector的线性数据的“矩阵视图”。

#include <vector>
#include <iostream>

struct cell
{
   std::size_t i, j;
   bool mine;
};

class minefield
{
public:
    minefield(int rows, int columns): cells(rows*columns), rowSize(columns)
    {
        std::cout << "just allocated std::vector\n";
    }
    virtual ~minefield()
    {
        std::cout << "about to free std::vector\n";
    }
    bool stepOn(std::size_t i, std::size_t j)
    {
        return cells.at(i*rowSize + j).mine;
    }
    void set(cell c)
    {
        cells[c.i*rowSize + c.j] = c;
    }
private:
    std::vector<cell> cells;
    int rowSize;
};


void funct() {
    minefield mf(5, 5);
    mf.set(cell{0, 0, false});
    mf.set(cell{0, 1, true});

    if (not mf.stepOn(0, 0))
    {
        std::cout << "still alive :)\n";
    }
    if (mf.stepOn(0, 1))
    {
        std::cout << "dead XP\n";
    }
}
int main()
{
    funct();
    std::cout << "bye!!\n";
}

这应该打印：

刚刚分配的std :: vector

还活着：）

XP死机

关于免费std :: vector

再见！

在std :: vector中释放指针内存的最有效方法是什么？

1 个答案: