如何跟踪 C++ 中的内存分配，尤其是那些由 new/delete 完成的分配。对于一个对象，我可以轻松地覆盖 operator new，但我不确定如何全局覆盖所有分配，因此它们会通过我的自定义 new/delete 。这应该不是什么大问题，但我不确定这应该如何完成(#define new MY_NEW?)。

一旦这个工作正常，我会假设在某处有一个分配指针/位置的映射就足够了，所以我可以跟踪所有当前“事件”的分配 - 在应用程序结束时 -检查尚未释放的分配。

嗯，这似乎又是一件至少肯定已经做过几次的事情，所以那里有什么好的库(最好是可移植的)？

最佳答案

我建议你使用 valgrind for linux。它将捕获未释放的内存，以及写入未分配内存等其他错误。另一个选项是 mudflap，它也告诉你没有释放内存。使用 gcc 的 -fmudflap -lmudflap 选项，然后使用 MUDFLAP_OPTIONS=-print-leaks ./my_program 启动您的程序。

这里有一些非常简单的代码。它不适合复杂的跟踪，但旨在向您展示原则上您将如何做到这一点，如果您要自己实现它。像这样(省略了调用已注册的 new_handler 和其他详细信息的内容)。

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\n";
            ++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\n";
    }
    std::free(mem);
}

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

我们必须为我们的 map 使用我们自己的分配器，因为标准分配器将使用我们覆盖的运算符 new，这将导致无限递归。

确保如果您覆盖 operator new，您使用 map 来注册您的分配。删除由 new 的放置形式分配的内存也将使用该 delete 运算符，因此如果您不知道的某些代码重载了 operator new 而不使用您的 map，这可能会变得很棘手，因为 operator delete 会告诉您它没有被分配并且使用 std::free 释放内存。

还请注意，正如 Pax 也为他的解决方案指出的那样，这只会显示由使用我们自己定义的运算符 new/delete 的代码引起的泄漏。因此，如果您想使用它们，请将它们的声明放在头文件中，并将其包含在所有应查看的文件中。

关于c++ - 如何在 C++ 中跟踪内存分配(尤其是新建/删除)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/438515/