So verfolgen Sie die Speicherzuweisung bei Verwendung von Smartpointer

Question

Ich versuche, eine Tracking-Klasse zu erstellen, um die Speicherzuordnung zu verfolgen. Beispiel: Wie viele Bytes werden in der Anwendung zugewiesen? Für die Variablen, die den neuen Operator/delete verwenden. Ich könnte Operator new/delete verwenden. Aber wie wäre es mit dem Speicher, der von intelligenten Zeigern zugewiesen wird?

#include <memory> 
#include <iostream> 

using namespace std; 
template<T> 
class MemoryTracking : std::enable_shared_from_this<MemoryTracking<T> > 
{ 
public: 
    static size_t s_total; 
    void* operator new (const size_t s) 
    { 
    s_total += s; 
    return ::operator new[](s); 
    } 
    void* operator new[](const size_t s) 
    { 
    s_total +=s; 
    return ::operator new[](s); 
    } 
    void delete(void *p, size_t s) noexcept 
    { 
    s_total -= s; 
    ::operator delete(p); 
    } 
    void delete[](void *p, size_t s) noexcept 
    { 
    s_total -= s; 
    ::operator delete[](p); 
    } 

    // for shared_ptr 
    MemoryTracking() throw() {}; 
    MemoryTracking(const MemoryTracking& other) throw() {}; 

    MemoryTracking<T>& operator = (const MemoryTracking<T>& other) { return *this; } 
    MemoryTracking<T>& operator = (const MemoryTracking& other) { return *this; } 
    ~MemoryTracking() {} 

    T* allocate(size_t n, const void* hint = 0) 
    { 
    return static_cast<T*>(::operator new(n * sizeof(T))); 
    } 

    void deallocate(T* ptr, size_t n) 
    { 
    ::operator delete(ptr); 
    } 

    template <typename U> 
    inline bool operator == (const MemoryTracking<U>&) 
    { 
    return true; 
    } 

    template <typename U> 
    inline bool operator != (const MemoryTracking<U>& obj) 
    { 
    return !(*shared_from_this() == obj); 
    } 
}; 

class A : public MemoryTracking<A> 
{ 
} 

int main() 
{ 
    auto ptr = make_shared<A>(); 
    cout << MemoryTracking::s_total << endl; 
} 

Answer 1

Wenn Sie wollen, dass alle in der Anwendung zugewiesenen Speicher verfolgen, sollten Sie stattdessen malloc() außer Kraft zu setzen, realloc(), calloc() und free(). Indem Sie diese vier überschreiben, erfassen Sie nicht nur C++ - Zuweisungen, sondern auch C-Zuweisungen.

Für wie Funktionen wie malloc() einzuwickeln finden Sie unter: How to reimplement (or wrap) a syscall function in linux? oder Globally override malloc in visual c++