数组中对象的内存分配

Question

这是我的代码 [注意我注释了 cstr 和析构函数]

#include <iostream>
#include <stdlib.h>
#include <array>

class MyIntClass
{
    int _mymember;

  public:  

// MyIntClass(){}
// ~MyIntClass(){}

void *operator new(size_t size)
{
    std::cout << "new: Allocating " << size << " bytes of memory" << std::endl;
    void *p = malloc(size);

    return p;
}
void operator delete(void *p)
{
    std::cout << "delete: Memory is freed again " << std::endl;
    free(p);
}


void *operator new[](size_t size)
{
    std::cout << "new: Allocating " << size << " bytes of memory" << std::endl;
    void *p = malloc(size);

    return p;
}

  void operator delete[](void *p)
    {
        std::cout << "delete: Memory is freed again " << std::endl;
        free(p);
    }
};

void line(){
        std::cout << "\n--------------------------------------------------\n" << std::endl;
}

int main()
{
    line();
    std::cout << "Using new overloading and malloc\nWe will create one object of MyIntClass that is supposed to be 4 bytes" << std::endl;
    MyIntClass *m1 = new MyIntClass();

    line();
    //I want to create an array of the MyIntClass of two objects
    std::cout << "Now we create array of MyIntClass using <array> header" << std::endl;
    std::array<MyIntClass, 2> z = {};

    std::cout << " The elements in the array z = "<< z.size() <<std::endl;

    std::cout << "The memory allocated for  array z = " << sizeof(z) << std::endl;

    line();

    std::cout << "\nNow we create array using new[] overloading and malloc " << std::endl;

    MyIntClass *i = new MyIntClass[2]();
    delete[] i;
}

现在结果如下：

---

使用新的重载和 malloc
我们将创建一个 MyIntClass 对象，它应该是 4 个字节

新：分配 4 个字节 记忆

---

现在我们使用 <array> header 创建 MyIntClass 数组
数组中的元素 z = 2
为数组 z = 8 分配的内存

---

现在我们使用 new[] 重载和 malloc 创建数组
新：分配 8 个字节的内存

对于没有经验的 C++ 程序员来说，我认为每件事都按预期工作

现在如果我取消注释构造函数，同样的结果会发生

但是，当我取消注释析构函数时，会出现不同的结果

现在我们使用 new[] 重载和 malloc 创建数组
新：分配 12 字节内存

所以我的问题是对此有何解释： 在使用array 库或重载new[] 和malloc 的两种方法中，创建两个对象的数组，每个对象都是4 字节，将导致为数组分配8 字节的内存。

然而，当我们有一个对象的析构函数时，malloc 将为这个 2 个元素的数组分配 12 个字节而不是 8 个字节。

我看到了这个question on SO，但它没有解释我的情况

以下是我的编译器版本：

gcc 版本 8.2.0 (MinGW.org GCC-8.2.0-3)

Answer 1

额外分配内存的原因是编译器需要知道数组中元素的数量，以便在您调用delete[] 时能够对数组的每个元素调用析构函数。对于一般可破坏的类型，编译器不需要调用析构函数，因此不需要额外的数组大小空间。