làm thế nào để đếm số lượng các đối tượng được tạo trong C++

Question

làm thế nào để đếm số lượng các đối tượng được tạo trong C++

xin giải thích với một ví dụ đơn giản

Answer 1

Số đối tượng để làm gì? Nếu bạn muốn đếm số đối tượng của một lớp cụ thể, bạn có thể sử dụng bộ đếm tĩnh. Một cái gì đó như dưới đây .. Tăng truy cập vào sáng tạo và sụt lần trong khi phá hủy ..

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

int A :: counter = 0; 

Answer 2

Bạn có thể tạo một biến truy cập vào công chúng: các lớp học của bạn (giả sử ở đây bạn đang nói về đếm các đối tượng từ một lớp học mà bạn đã tạo)

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; 

Taken từ ddj.com

Answer 3

Tạo lớp mẫu với một bộ đếm tĩnh.

Mỗi đối tượng trong ứng dụng của bạn sau đó sẽ mở rộng lớp mẫu này.

Khi hàm tạo được gọi là số tĩnh tăng (biến tĩnh là mỗi lớp - được chia sẻ bởi tất cả các đối tượng của lớp đó).

Ví dụ thấy Object Counter sử dụng 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> 
{ 
    // ... 
}; 

Cách sử dụng cho đầy đủ:

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

Output:

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

Kỹ thuật này được gọi là CRTP

Answer 5

Bạn phải quá tải các toán tử mới và xóa để tính phân bổ bộ nhớ.

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

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