如何在C ++中解除分配？

Question

I create a 2D array of Nodes ( Node class is in a separate file) and i'm wondering how to deallocate exactly this (below). I've tried many ways and mem leaks still appear.

board = new Node * [r];

//creats a column for each element in the row
for(int i = 0; i < r; i++) {
    board [i] = new Node [c];
}

( r is the rows and c is the cols)

I've done this:

for(int i = 0; i < r; i++) {

    delete [] board[i];
}

delete [] board;

But apparently it's not enough

Answer 1

The code you have is correct and sufficient. However, it would be better to use RAII so that you do not need to explicitly call delete at all (perhaps not even new ). For example, you could create a std::vector<std::vector<Node>> , or better still, some sort of matrix class (not in the standard library, unfortunately).

Answer 2

Your solution is the correct way to free two dimensional array. However you may still get a memory leak if Node uses dynamic memory and it's destructor is not properly defined.

Answer 3

As others have said, you're correctly pairing up all your new[] s and delete[] s: assuming no errors occur, the memory allocated by this code will be correctly deallocated.

The only issue is that errors may occur, and in particular exceptions may be thrown:

• new[] can throw an exception if it fails to allocate memory (doesn't normally happen on desktop OSes, but you should still write code as if it does.)
• Node 's constructor may throw. Even if you've designed the constructor not to throw you generally shouldn't take advantage of that knowledge. Just write code as if throws.
• In fact, you should just generally write code as if pretty much anything can throw. For more detailed info on writing exception safe code, and on what the exceptions to this rule are you can read the info at http://exceptionsafecode.com

The best way to make this code exception safe is to use RAII. For example use a vector instead of new[] / delete[] .

---

Using an array of pointers and a separate allocation for each row makes sense for 'ragged' arrays, where each row can be a different length. In your case you have rectangular array, so you can use a single allocation for the whole thing.

std::vector<Node> board(rows*columns);

board[row_index*columns + column_index] // replaces board[row_index][column_index]

You can hide the implementation by putting this in a class:

class Board {
  std::vector<Node> board_data;
public:
  const int rows;
  const int columns;

  Board(int rows_, int columns_)
    : board_data(rows_*columns_)
    , rows(rows_)
    , columns(columns_)
  {}

  struct board_index { int row, column; };

  Node &operator[](board_index i) {
    assert(0 <= i.row && i.row < rows);
    assert(0 <= i.column && i.column < columns);
    return board_data[i.row * columns + i.column];
  }
};

Board board(r, c);

with the above implementation you replace board[i][j] with board[{i, j}] .

board[{i, j}] = ... // assign to a place on the board
board[{i, j}].foo(); // call a Node method
std::cout << board[{i, j}]; // print a Node
// etc.