How to check memory leak when dealing with linked-list naked pointer style?

When dealing with naked pointer, what is the best way to make sure that memory get released? For example, implemented linked-list using C style.

#include <iostream>

using namespace std;

struct node {
    int value;
    node* next;
    node( int value ) : value( value ), next( NULL ) {
    }
};

void put( node* root, int value ) {
    node *newnode = new node( value );
    while( root->next )
        root = root->next;
    root->next = newnode;
}

node* pick( node *root ) {
    if( root->next ) {
        node* temp = root->next;
  开发者_运维知识库      root->value = root->next->value;
        root->next = root->next->next;
        delete temp;
        return root;
    }
    return NULL;
}

struct las {
private:
    node *a;
public:
    las() {
        a = new node( 0 );
        a->next = new node( 1 );
    }

    void next() {
        node* na = new node( 0 );
        while( a->next ) {
            pick( a );
            int count;
            int value = a->value;
            for( count = 1; a->next && a->value == a->next->value; count++ ) {
                pick( a );
            }
            put( na, count );
            put( na, value );
        }
        delete a;
        a = na;
    }

    friend  
    ostream& operator <<( ostream& os, const las& olas ) {
        node* root = olas.a;
        while( root->next ) {
            root = root->next;
            os << root->value;
        }
        return os;
    }
};

int main() {
    las* ls = new las();
    int n = 10;
    for( int i = 0; i < n; i++ ) {
        cout << *ls << endl;
        ls->next(); 
    }

    delete ls;
    return 0;
}

I'm not the author of this code, so how can I find out is there memory in this program?

---

An alternative to a heap checker if you know which object may be a culprit is to manually instrument your code:

unsigned nodes = 0;
struct node {
    ~node()
    {
        --nodes;
    }
    int value;
    node* next;
    node( int value ) : value( value ), next( NULL ) {
        ++nodes;
    }
};

Then:

int main()
{
    // etc.
    delete ls;
    std::cout << "Nodes: " << nodes << std::endl;
    return 0;
}

This kind of light weight check can be built into a unit test (or even production code), ensuring that you pick up the leak as soon as possible. You might wrap it in NDEBUG so as to remove cleanly from a release build when wanted.

---

Valgrind is a good tool for finding memory leaks.

---

Use a memory profiler, like Valgrind.

---

Have you tried using valgrind? It seems to be a pretty standard tool for checking for memory leaks.

---

You need a detector of some sort, either in the form of a library (which generally hooks in by overriding new, so can cause issues in rare conditions) or an external program made for finding leaks.

---

If you don't wish to use Valgrind or equivalent, you could have your list nodes increment a static counter when they are created and decrement it when they are destroyed. This counter can tell you if you leak, but not where.