C++ 数组中对象的内存分配

这是我的代码[注意，我对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;
}

#包括
#包括
#包括但没有解释我的情况

以下是我的编译器版本：

gcc版本8.2.0（MinGW.org gcc-8.2.0-3）

额外分配内存的原因是编译器需要知道数组中元素的数量，以便在调用
delete[]
时能够调用数组中每个元素的析构函数。对于普通的可销毁类型，编译器不需要调用析构函数，因此不需要为数组大小提供额外的空间。
额外分配内存的原因是，编译器需要知道数组中的元素数，以便在调用
delete[]时能够对数组的每个元素调用析构函数
。对于普通的可破坏类型，编译器不需要调用析构函数，因此不需要为数组大小提供额外的空间。
删除所有这些多余的空行将使您的代码更具可读性—所有这些都不会对实际代码做任何更改！什么是“memalloc”？程序的行为是未定义的，因为您对不是由
new
（它是由
new[]
返回的）返回的指针使用
delete
。请尝试打印出
sizeof（MyIntClass）
用于类的各种配置。@Yksisarvinen否。请使用
delete[]以外的任何方法
释放分配了
new[]的指针
具有未定义的行为。不管重载运算符如何。删除所有这些多余的空行将使您的代码更具可读性-所有这些都不会对实际代码进行任何更改！什么是“memalloc”？程序的行为是未定义的，因为您对不是由
new
（它是由
new[]
返回的）返回的指针使用
delete
。请尝试打印出
sizeof（MyIntClass）
用于类的各种配置。@Yksisarvinen否。请使用
delete[]以外的任何方法
释放分配了
new[]的指针
具有未定义的行为。不管重载运算符如何。您说过“编译器需要知道数组中元素的数量，以便能够调用析构函数”，但是这里已经指定了该数量
std:：array z={}这里是
MyIntClass*i=newmyintclass[2]（）；那么，尽管我们在编译时而不是运行时指定了元素的数量，但为什么分配的空间是不同的呢？我仍然感到困惑，但感谢您的回复
std:：array
（和C样式的数组）并没有动态分配内存。数组的大小总是
N*sizeof（T）
，其中N在编译时已知，不需要单独存储。重要的一点是，在销毁数组时，编译器静态地知道N。OTOH，当您调用
操作符new[]
时，元素数是一个运行时值（即使您将其指定为常量），它不能从返回的指针推断出来。该运行时值需要存储在某个位置，以便
operator delete[]
能够调用析构函数这里是
MyIntClass*i=newmyintclass[2]（）；那么，尽管我们在编译时而不是运行时指定了元素的数量，但为什么分配的空间是不同的呢？我仍然感到困惑，但感谢您的回复
std:：array
（和C样式的数组）并没有动态分配内存。数组的大小总是
N*sizeof（T）
，其中N在编译时已知，不需要单独存储。重要的一点是，在销毁数组时，编译器静态地知道N。OTOH，当您调用
操作符new[]
时，元素数是一个运行时值（即使您将其指定为常量），它不能从返回的指针推断出来。该运行时值需要存储在某个位置，以便
operator delete[]
能够调用析构函数。