Counting of objects created in stack and heap for many classes

Question

What is the best way to count the total number of objects created in both stack and heap for different classes. I know that in C++ new and delete operators can be overloaded and hence in the default constructor and destructor the object count can be incremented or decremented as and when the objects get created or destroyed.

Further if i am to extend the same thing for object counting of objects of different classes, then i can create a dummy class and write the object count code in that class and then when i create any new class i can derive it from the Dummy class.

Is there any other optimal solution to the same problem.

The best way is not to bother - why do you think you need to do this? — , Jun 09 '10 at 10:31
Basically a duplicate of http://stackoverflow.com/questions/1926605/ — Björn Pollex, Jun 09 '10 at 10:51
Do you want to count only objects on stack & heap? Not in globals, function-level statics, temporaries, or exceptions? @Space_cowboy: not really, if you need to exclude certain objects based on their lifetime. — MSalters, Jun 09 '10 at 11:47

score 4 · Accepted Answer · answered Jun 09 '10 at 10:35

then i can create a dummy class and write the object count code in that class and then when i create any new class i can derive it from the Dummy class.

Yes, but since each class needs its own count, you have to make a base class template and use the curiously recurring template pattern (CRTP):

template <class Derived>
class InstanceCounter
{
    static int count;

protected:

    InstanceCounter()
    {
        ++count;
    }

    ~InstanceCounter()
    {
        --count;
    }

public:

    static int instance_count()
    {
        return count;
    }
};

template <class Derived>
int InstanceCounter<Derived>::count = 0;

class Test : public InstanceCounter<Test>
{
};

int main()
{
    Test x;
    std::cout << Test::instance_count() << std::endl;
    {
        Test y;
        Test z;
        std::cout << Test::instance_count() << std::endl;
    }
    std::cout << Test::instance_count() << std::endl;
}

score 0 · Answer 2 · answered Nov 13 '19 at 11:00

The way the object is created in stack and heap is different. The new operator is used create an object in heap, and normal object declaration will create an object in stack. So by overloading an new operator we can count the object created in heap.

static variable can be used to count the objects.

Girish · Answer 3 · 2019-07-27T04:22:57.780

To find the no of objects created on Heap and Stack. To create the object on the heap we use new so override the new and delete keywords to keep track of the counter.

class Test
{
    static int heapcount;
    static int stackcount;

public:
    static int GetHeapCount()
    {
        return heapcount;
    }

    static int GetStackCount()
    {
        //The objects which are created on heap also will call constructor and increment the stack count, so remove the objects that are created on heap to get stack count
        return stackcount - heapcount;
    }

    Test()
    {
        ++stackcount;
    }

    ~Test()
    {
        --stackcount;
    }

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

    void operator delete(void* p)
    {
        --heapcount;
        free(p);
    }

    void operator=(Test const& obj)
    {
        int x = 0;
    }
};
int Test::heapcount = 0;
int Test::stackcount = 0;

int main()
{
    {
        Test t;
        Test t2;
        Test* t1 = new Test();
        std::cout << "HeapCount = " << Test::GetHeapCount() << std::endl;//HeapCount = 1 (t1)
        std::cout << "StackCount = " << Test::GetStackCount() << std::endl;//StackCount = 2 (t,t2)

        delete t1;
    }
//As all the objects are deleted so count must be zero, stack objects will be removed when goes out of scope
    std::cout << "HeapCount = " << Test::GetHeapCount() << std::endl;//HeapCount = 0
    std::cout << "StackCount = " << Test::GetStackCount() << std::endl;//StackCount=0

    {
        Test t[3];
        Test* t2 = new Test();
        Test* t3 = new Test();
        std::cout << "HeapCount = " << Test::GetHeapCount() << std::endl;//HeapCount = 2 (t2,t3)
        std::cout << "StackCount = " << Test::GetStackCount() << std::endl;//StackCount = 3 (t[3])
    }

//Two heap objects are not deleted, but stack objects has been cleaned
    std::cout << "HeapCount = " << Test::GetHeapCount() << std::endl;//HeapCount = 2
    std::cout << "StackCount = " << Test::GetStackCount() << std::endl;//StackCount = 0
}

Your answer would be more useful if you explain what the code does. — Acapulco, Jul 25 '19 at 18:11
new and delete should be static, and your `operator=` has a wrong return type and basically is not the copy assignment operator it should be given its argument. Other than that, your answer provide good pointers to achieve what was asked, so improved it a bit and explain the different part for everybody :) — Jaffa, Apr 28 '20 at 18:21

Counting of objects created in stack and heap for many classes

3 Answers3

Linked