jak policzyć liczbę obiektów utworzonych w C++

Question

jak policzyć liczbę obiektów utworzonych w C++

pls wyjaśnić w prosty przykład

Answer 1

liczba obiektów na co? Jeśli chcesz policzyć liczbę obiektów określonej klasy, możesz użyć statycznego licznika. Coś jak poniżej .. licznik Przyrost na tworzenie i ubytek while zniszczenie ..

class A 
{ 
    public: 
    static int counter; 
    A() 
    { 
     counter ++; 
    } 
    virtual ~A() 
    { 
     counter --; 
    } 
}; 

int A :: counter = 0; 

Answer 2

Można by utworzyć zmienną licznik do publiczności: od swojej klasie (zakładając tutaj mówisz zliczanie obiektów z utworzonej klasie)

class Widget { 
public: 
    Widget() { ++count; } 
    Widget(const Widget&) { ++count; } 
    ~Widget() { --count; } 

    static size_t howMany() 
    { return count; } 

private: 
    static size_t count; 
}; 
// obligatory definition of count. This 
// goes in an implementation file 
size_t Widget::count = 0; 

Zrobione z ddj.com

Answer 3

Tworzenie klasy szablonu ze statycznego licznika.

Każdy obiekt w aplikacji rozszerzy tę klasę szablonów.

Gdy konstruktor jest nazywany przyrostem licznika statycznego (zmienna statyczna przypada na klasę - współdzielona przez wszystkie obiekty tej klasy).

Na przykład patrz obiekt licznika za pomocą Curiously recurring template pattern:

template <typename T> 
struct counter 
{ 
    counter() 
    { 
     objects_created++; 
     objects_alive++; 
    } 

    virtual ~counter() 
    { 
     --objects_alive; 
    } 
    static int objects_created; 
    static int objects_alive; 
}; 
template <typename T> int counter<T>::objects_created(0); 
template <typename T> int counter<T>::objects_alive(0); 

class X : counter<X> 
{ 
    // ... 
}; 

class Y : counter<Y> 
{ 
    // ... 
}; 

Wykorzystanie dla kompletności:

int main() 
{ 
    X x1; 

    { 
     X x2; 
     X x3; 
     X x4; 
     X x5; 
     Y y1; 
     Y y2; 
    } // objects gone 

    Y y3; 

    cout << "created: " 
     << " X:" << counter<X>::object_created 
     << " Y:" << counter<Y>::object_created 
     << endl; 

    cout << "alive: " 
     << " X:" << counter<X>::object_alive 
     << " Y:" << counter<Y>::object_alive 
     << endl; 
} 

wyjściowa:

created: X:5 Y:3 
alive: X:1 Y:1 

Answer 4

template <class T> 
class Counter 
{ 
    private: 
     static int count; 
    public: 
    Counter() 
    { 
     count++; 
    } 
    Counter(const Counter &c) 
    { 
     count++; 
    } 
    ~Counter() 
    { 
     count--; 
    }  
    static int GetCount() { 

     return count; 
    } 
} 

template<class T> 
int Counter<T>::count = 0; 



class MyClass : private Counter<MyClass> 
{ 
    public: 
     using Counter<MyClass>::GetCount; 
} 

Ta technika nazywa CRTP

Answer 5

Musisz przeciążać nowych i usuwać operatorów , aby zliczyć alokację pamięci.

void * operator new (size_t size) 
{ 
    void * p = malloc (size); 
    num_allocations++; 
    return p; 
} 

void operator delete (void * p) 
{ 
    num_deletions++; 
    free (p); 
}