在n元树中创建/访问节点时发生内存泄漏

Question

I'm getting memory leaks from the following code:

struct Node {
    Node *children[20];
    int value;

    Node();
    ~Node();
};

Node::Node() {
    for(int i=0; i<20; i++) {
        children[i] = NULL;
    }
}

void Node::insert(int x) {
    Node *n = this;
    for(int i=0; i<20; i++) {
        if(n->children[i] == NULL) {
            n->children[i] = new Node();
            n->children[i]->value = x;
        }
        n = n->children[i];
    }
}  

Checking with Valgrind, apparently I'm getting a leak from this line:

n->children[i] = new Node();

Is this a wrong way to use the constructor?
Or is the Valgrind check misleading?

Valgrind Error message:

505 (448 direct, 57 indirect) bytes in 2 blocks are definitely lost in loss record 2 of 3
  at 0x4C2B1C7: operator new(unsigned long)
  by 0x401A4F: Node::insert
  by 0x4015FA: main

LEAK SUMMARY:
  definitely lost: 448 bytes in 2 blocks
  indirectly lost: 57 bytes in 2 blocks
    possibly lost: 0 bytes in 0 blocks
  still reachable: 72,704 bytes in 1 blocks
       suppressed: 0 bytes in 0 blocks

ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 2 from 2)  

The Destructor I have:

Node::~Node() {
    for(int i=0; i<20; i++) {
        delete children[i];
        children[i] = NULL;
    }
}

In main:

int main() {
    Node *n = new Node();

    .
    .
    .

    delete n;
    n = NULL;

    return 0;
}

Answer 1

You are not deleting the children. As answered by Axel, you should add a delete in your destructor. Or better, use an array of unique_ptr, that will take care of destroying the nodes when they get out of scope.

Answer 2

You never delete children pointers.

You should delete each allocated pointer of children array in the Node class destructor.

Like that :

Node::~Node()
{
    for (int i = 0; i < 20; ++i)
    {
        delete children[i];
    }
}

Moreover, if there is any other method which replace pointers in children array, you have to delete the previous pointer before replacing it, like that:

...
delete n->children[i];
n->children[i] = new Node();
...

or

...
delete n->children[i];
n->children[i] = p;  // where p is a pointer of Node
...

For information, you have to call delete to destroy and deallocate each object you construct on the heap (using new ).

You could also use smartpointer to avoid to manage children members destruction.

Answer 3

I see one new, but no delete's, nor smart pointers. That means you allocate memory without freeing it accordingly. (At least you did not show us the destructor of Node where that should be done.)

Apart from that there are several flaws in your code:

• Your use of n looks suspicious and it is not clear if what it does is the right thing or simply a bug. You may want to at least clarify that by a comment or better by using additional functions and meaningful names.
• You don't stop once you have found a NULL pointer and flood the whole array with new Nodes, meaning you can successfully insert exaclty once
• You default-construct a node and assign it a value immediately - probably you should write a corresponding constructor.

Use smart pointers to allocate your memory:

struct Node {
    unique_ptr<Node> children[20]; //consider switching to std::array
    int value;

    // no destructor needed, because unique_ptr takes care of itself    
    Node (int newValue);
    void insert(int valueToInsert);
};


void Node::insert(int valueToInsert) {
    auto freeSpot = //find the point where you want to insert the new node
    if ( /*freeSpot is a valid location*/ )
        *freeSpot = make_unique<Node>(x);
}  

Node::Node(int newValue) 
  : value(newValue)
{}

That would be a first refactoring you could do