, wie die Anzahl der Objekte in c erstellt zählen ++

Question

, wie die Anzahl der Objekte in c erstellt zählen ++

pls erklärt mit einem einfachen Beispiel

Answer 1

Anzahl der Objekte für das, was? Wenn Sie die Anzahl der Objekte einer bestimmten Klasse zählen möchten, können Sie einen statischen Zähler verwenden. So etwas wie unten .. Zähle bei der Erstellung und Abnahme während Zerstörung ..

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

int A :: counter = 0; 

Answer 2

Sie könnten eine Zählvariable in der Öffentlichkeit schaffen: Ihrer Klasse (vorausgesetzt, hier Sie sprechen über Objekte aus einer Klasse zählen Sie erstellt

)

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; 

Entnommen ddj.com

Answer 3

Template-Klasse mit einem statischen Zählern erstellen.

Jedes Objekt in Ihrer Anwendung würde dann diese Vorlagenklasse erweitern.

Wenn Konstruktor inkrementierte statische Anzahl aufgerufen wird (statische Variable ist pro Klasse - für alle Objekte dieser Klasse gemeinsam).

Zum Beispiel siehe Objektzähler mit 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> 
{ 
    // ... 
}; 

Verwendung der Vollständigkeit halber:

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; 
} 

Ausgang:

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; 
} 

Diese Technikgenannt wird

Answer 5

Sie müssen die neuen Operatoren überladen und löschen, um die Speicherzuweisungen zu zählen.

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

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