How can I track the memory allocations in C++, especially those done by new/delete. For an object, I can easily override the operator new, but I'm not sure how to globally override all allocations so they go through my custom new/delete. This should be not a big problem, but I'm not sure how this is supposed to be done (#define new MY_NEW?).

只要這可行，我就會假設在分配的指針/位置的某處有一個映射就足夠了，這樣我就可以跟蹤當前活動"的所有分配，并且 - 在應用程序結束時 -檢查尚未釋放的分配.

As soon as this works, I would assume it's enough to have a map somewhere of pointer/location of the allocation, so I can keep track of all allocations which are currently 'active' and - at the end of the application - check for allocations which have not been freed.

嗯，這似乎又是一件肯定至少已經做過幾次的事情，所以有什么好的圖書館(最好是便攜式的)?

Well, this seems again like something that surely has been done several times at least, so any good library out there (preferably a portable one)?

推薦答案

我建議你使用 valgrind for linux.它將捕獲未釋放的內存，以及其他錯誤，例如寫入未分配的內存.另一種選擇是mudflap，它也告訴您未釋放的內存.在 gcc 中使用 -fmudflap -lmudflap 選項，然后使用 MUDFLAP_OPTIONS=-print-leaks ./my_program 啟動你的程序.

I would recommend you to use valgrind for linux. It will catch not freed memory, among other bugs like writing to unallocated memory. Another option is mudflap, which tells you about not freed memory too. Use -fmudflap -lmudflap options with gcc, then start your program with MUDFLAP_OPTIONS=-print-leaks ./my_program.

這是一些非常簡單的代碼.它不適合復雜的跟蹤，但旨在向您展示原則上如何進行，如果您要自己實現它.像這樣的東西(省略了調用注冊的 new_handler 和其他細節的東西).

Here's some very simple code. It's not suitable for sophisticated tracking, but intended to show you how you would do it in principle, if you were to implement it yourself. Something like this (left out stuff calling the registered new_handler and other details).

template<typename T>
struct track_alloc : std::allocator<T> {
    typedef typename std::allocator<T>::pointer pointer;
    typedef typename std::allocator<T>::size_type size_type;

    template<typename U>
    struct rebind {
        typedef track_alloc<U> other;
    };

    track_alloc() {}

    template<typename U>
    track_alloc(track_alloc<U> const& u)
        :std::allocator<T>(u) {}

    pointer allocate(size_type size, 
                     std::allocator<void>::const_pointer = 0) {
        void * p = std::malloc(size * sizeof(T));
        if(p == 0) {
            throw std::bad_alloc();
        }
        return static_cast<pointer>(p);
    }

    void deallocate(pointer p, size_type) {
        std::free(p);
    }
};

typedef std::map< void*, std::size_t, std::less<void*>, 
                  track_alloc< std::pair<void* const, std::size_t> > > track_type;

struct track_printer {
    track_type * track;
    track_printer(track_type * track):track(track) {}
    ~track_printer() {
        track_type::const_iterator it = track->begin();
        while(it != track->end()) {
            std::cerr << "TRACK: leaked at " << it->first << ", "
                      << it->second << " bytes
";
            ++it;
        }
    }
};

track_type * get_map() {
    // don't use normal new to avoid infinite recursion.
    static track_type * track = new (std::malloc(sizeof *track)) 
        track_type;
    static track_printer printer(track);
    return track;
}

void * operator new(std::size_t size) throw(std::bad_alloc) {
    // we are required to return non-null
    void * mem = std::malloc(size == 0 ? 1 : size);
    if(mem == 0) {
        throw std::bad_alloc();
    }
    (*get_map())[mem] = size;
    return mem;
}

void operator delete(void * mem) throw() {
    if(get_map()->erase(mem) == 0) {
        // this indicates a serious bug
        std::cerr << "bug: memory at " 
                  << mem << " wasn't allocated by us
";
    }
    std::free(mem);
}

int main() {
    std::string *s = new std::string;
        // will print something like: TRACK: leaked at 0x9564008, 4 bytes
}

我們必須為我們的地圖使用我們自己的分配器，因為標準分配器將使用我們覆蓋的運算符 new，這將導致無限遞歸.

We have to use our own allocator for our map, because the standard one will use our overridden operator new, which would result in an infinite recursion.

確保如果您覆蓋 operator new，您使用映射來注冊您的分配.刪除由 new 的放置形式分配的內存也將使用該 delete 運算符，因此如果您不知道的某些代碼重載了 operator new 而不使用您的映射，這可能會變得棘手，因為運算符 delete 會告訴您它沒有分配并且使用 std::free 釋放內存.

Make sure if you override operator new, you use the map to register your allocations. Deleting memory allocated by placement forms of new will use that delete operator too, so it can become tricky if some code you don't know has overloaded operator new not using your map, because operator delete will tell you that it wasn't allocated and use std::free to free the memory.

另請注意，正如 Pax 在他的解決方案中指出的那樣，這只會顯示由使用我們自己定義的運算符 new/delete 的代碼引起的泄漏.因此，如果您想使用它們，請將它們的聲明放在標題中，并將其包含在所有應注意的文件中.

Also note, as Pax pointed out for his solution too, this will only show leaks that are caused by code using our own defined operator new/delete. So if you want to use them, put their declaration in a header, and include it in all files that should be watched.

這篇關于如何在 C++ 中跟蹤內存分配(尤其是新建/刪除)的文章就介紹到這了，希望我們推薦的答案對大家有所幫助，也希望大家多多支持html5模板網！