malloc、free和new、delete的区别

//malloc和free，称作c的库函数
//new和delete，称作运算符
/**********************************************/
//malloc按照字节开辟内存,返回值是void *,需要做类型强转
//仅开辟内存，不做初始化;malloc开辟内存失败，是通过返回值和nullptr比较
//new 是指定类型开辟内存，返回指定类型的类型指针；new不仅可以做内存开辟，还可以做内存初始化操作；new开辟内存失败是通过抛出bad_alloc的异常来判断的int *p=(int *)malloc(sizeof(int));
if (p==nullptr)
{return -1;
}
*p=20;//需要单独进行初始化
free(p);//等效的new和delete操作为
try
{
int *p1=new int (20);
}
catch(const bad_alloc &e)
{}
delete p1;//开辟数组类型的操作
int *q=(int *)malloc(sizeof(int)*20);
if (q==nullptr)
{return -1;
}
free(q);int *q1=new int[20];//仅负责开辟内存
int *q1=new int[20]();//这种会初始化开辟的内存为零，不能传入其他值
delete []q1;

new的种类

int *p1=new int(20);int *p2=new (nothrow) int;//不抛出异常const int *p3=new const int(40); //堆上开辟常量//定位new
int data=0;
int *p4=new (&data) int(50);//指定在data的地址，划分出内存，并可以赋值
cout<<"data:"<<data<<endl;

new/delete 与 new[]/delete[] 不可混用的深层原因

首先重载new和delete 以及new []和delete []运算符

//这里是全局运算符重载
//先开辟内存空间，再调用对象构造函数
void* operator new(size_t size)
{void* p = malloc(size);if (p == nullptr){throw bad_alloc();}cout << "operator new addr:" << p << endl;return p;
}//先析构对象，再清除内存空间
void operator delete(void* ptr)
{free(ptr);cout << "operator delete addr:" << ptr << endl;
}/*构造数组类型*/
void* operator new[](size_t size)
{void* p = malloc(size);if (p == nullptr){throw bad_alloc();}cout << "operator new[] addr:" << p << endl;return p;
}void operator delete[](void* ptr)
{cout << "operator delete addr:" << ptr << endl;free(ptr);
}

情况1

随后自定义一个Test类，用以分析new和delete。

//自定义的Test类，
class Test
{
public:Test()  { cout << "Test" << endl; }~Test() {  cout << "~Test" << endl; }
private :int x;
};
int main()
{	Test* p = new Test[5];cout << "Test类的大小：" << sizeof(Test) << endl;cout << "首个对象的地址:" << p << endl;delete[]p;
}

根据实验结果，可以发现开辟的内存其实地址和返回的首元素对象地址相差8个字节，这是因为当使用new[]的时候，编译器在开辟内存空间的时候会专门开辟8个字节（4或者8字节，根据编译器不同）用以存放数组的个数。所以这里开辟的内存空间应该是8+5*4=28个字节。

而如果在delete的时候，选择delete p,编译器认为这只是一个简单的对象，只是把数组中首元素进行了删除，而不是从p-8的位置开始释放，从而造成了内存泄露。

情况2

int main()
{	Test* p = new Test();delete []p;
}

创建new的时候是一个普通变量，但是在delete删除的时候告诉编译器这是一个数组。
那么编译器就会从p-8（非法内存）的位置读取虚构的数组长度值，并从p-8的位置开始释放内存。但是p-8的位置不是当前p所指向的合法空间，这是越界访问，从而出错。

小结

对于普通的编译器内置类型
new 和delete[],new[] 和delete是可以混用的。
new []和delete混用

new 和delete[]混用

**但是强烈不建议混用**！！！

对于自定义的类类型，存在析构函数，为了调用正确的析构函数，在开辟对象数组的时候，会多开辟4或8个字节，以记录对象的个数。