C ++指针结构不会被删除

Question

I have build a custom data-struct, that is something like a doubly linked RBTree, and while the logic seems fine, I don't see any memory getting released when I delete a node.

This is my node declaration:

typedef struct rbtreere_node
{

public:
    NMessage *n_message;

    // Node Specific //
    enum color color_ID;    //<<--- Color for ID side of RBTreeRe
    enum color color_Price; //<<--- Color for Price side of RBTreeRe
    int id;                 //<<--- Unique Identifier.
    rbtreere_node *left_ID, *right_ID, *parent_ID, *left_Price, *right_Price, *parent_Price;

}*node;

When I call my remove function, I end with a delete n before my return. I checked and if I try to access any of the node n data before returning, it is still there...

ie I'm calling this:

delete n;
std::cout << n->color_ID<<"\n\n";

and it does return a the node color

Should I build a custom destructor for it?

I also had the node message as a var, instead of a pointer, but that did not seem to change anything...

Edit: My issue is that I do not see any drop in memory usage after deleting any or even all nodes. Should I handle it differently?

Answer 1

I checked and if I try to access any of the node n data before returning, it is still there...

delete n;
std::cout << n->color_ID<<"\n\n";

Dereferencing n after it has been deleted has undefined behaviour.

Should I build a custom destructor for it?

No. Unless n_message owns the memory it points, in which case the implicit destructor would leak that memory.

My issue is that I do not see any drop in memory usage after deleting any or even all nodes.

Most implementations of malloc (which is what is typically used for dynamic memory allocation by the implementation of new ) never return freed memory to the operating system. Instead it reuses it for subsequent allocations. This is a non-issue.

Should I handle it differently?

Besides getting rid of the "check" that has UB, no. Everything appears to be as expected.

Answer 2

delete only deallocates memory and calls the object's destructor. It doesn't wipe the memory or do anything like that. And unless you have some need to (security, for instance) it's just a waste of time and code. After delete you can (and obviously are) still point to the memory and dereference it. It's very dangerous to do as it is undefined behavior.