C++: Why new an array of class with destructor will need another 8 bytes to store the number of objects?

In C++, when you create an array of class objects with a destructor, you may notice that it requires an additional 8 bytes of memory to store the number of objects. This may seem puzzling at first, but it has a logical explanation.

Let's start by understanding how arrays and objects are stored in memory. When you create an array of objects, the memory is allocated contiguously, meaning that the objects are stored one after another in memory.

Each object in the array has its own set of member variables and functions. Additionally, C++ keeps track of the size of each object in memory. This size information is crucial for memory management and proper destruction of objects.

When you define a class with a destructor, C++ automatically adds an additional hidden member variable to the class, known as the vtable (virtual table). The vtable is used for dynamic dispatch of virtual functions and other internal mechanisms.

Now, when you create an array of class objects with a destructor, C++ needs to store the number of objects somewhere in memory so that it knows how many objects to destruct when the array is destroyed.

C++ achieves this by using those extra 8 bytes of memory. It stores the number of objects just before the first object in the array. This way, when the array is destroyed, C++ can easily access the number of objects and call the destructor for each object.

Here's a simple example to illustrate this:

class MyClass {
public:
  ~MyClass() {
    // Destructor code
  }
};

int main() {
  MyClass* array = new MyClass[5];
  delete[] array;
  return 0;
}

In the above code, we create an array of 5 MyClass objects using the new keyword. When the array is deleted using delete[], C++ knows that it needs to call the destructor for each of the 5 objects.

Now, you might wonder why C++ needs those extra 8 bytes to store the number of objects, instead of using some other mechanism. The reason is efficiency and simplicity.

By storing the number of objects just before the first object in the array, C++ can easily access it when needed. This approach doesn't require any additional memory allocation or complex bookkeeping. It's a straightforward and efficient way to handle the destruction of objects in an array.

It's worth mentioning that the additional 8 bytes are not part of the objects themselves. They are used solely for bookkeeping purposes and are not accessible or visible to the user.

So, the next time you create an array of class objects with a destructor in C++, remember that those extra 8 bytes are there to ensure proper destruction of objects. It's a small price to pay for the convenience and reliability provided by C++'s memory management system.

In this article, we explored why creating an array of class objects with a destructor in C++ requires an additional 8 bytes of memory to store the number of objects. We learned that this is necessary for C++ to properly manage the destruction of objects in the array. Despite the additional memory overhead, this approach offers efficiency and simplicity in memory management. Understanding these underlying mechanisms can help you write more robust and efficient C++ code.

References