目录

malloc:

开辟失败：返回值为空指针

new:

内置类型：

申请一个int对象（开辟一块存储int类型数据的空间，只能存储一个int数据）：

申请5个int对象（开辟一块存储int类型数据的空间，能存储指定个int数据）：

申请一个int对象，且能指定初始化：

C++11特供版：支持new[ ]用{ }初始化，C++98不支持

自定义类型：

先堆上申请空间，再调用构造函数初始化：

开辟失败：抛异常

 delete:

内置类型：

用new申请一个对象的指针销毁：

用new申请多个对象的指针销毁：

自定义类型：

先调用析构函数清理对象中的资源，再释放空间

---

malloc:

int* p0=(int*)malloc(sizeof(int)*n)

开辟失败：返回值为空指针

char* ptr = (char*)malloc(1024u * 1024u * 1024u * 2 - 1);
printf("%p\n", ptr);

运行结果：

应对方式：if判断

if(ptr==NULL)
{
    perror(“malloc fail”);
    return;
}

---

new:

内置类型：

申请一个int对象（开辟一块存储int类型数据的空间，只能存储一个int数据）：

int* p1=new int;

申请5个int对象（开辟一块存储int类型数据的空间，能存储指定个int数据）：

//开辟能存储5个int的空间
int* p2=new int[5];

申请一个int对象，且能指定初始化：

//将开辟的一个存储int类型的新空间初始化为5
int* p3=new int(5);

C++11特供版：支持new[ ]用{ }初始化，C++98不支持

int* p4=new int[5]{1,2,3,4,5}

自定义类型：

先堆上申请空间，再调用构造函数初始化：

#include<iostream>
using namespace std;
class A
{
public:
	A(int a=0)
	:_a(a)
	{}

private:
	int _a;
};

int main()
{
    //无参
	A* p1 = new A;
    //含参
    A* p2 = new A(10);
}

开辟失败：抛异常

char* ptr2 = new char[1024u * 1024u * 1024u * 2 - 1];
printf("%p\n", ptr2);

 

应对方式：try ... catch

try
{
	char* ptr2 = new char[1024u * 1024u * 1024u * 2 - 1];
	printf("%p\n", ptr2);
}
catch (const exception& e)
{
	cout << e.what() << endl;
}

---

delete:

内置类型：

用new申请一个对象的指针销毁：

delete p1;
delete p3;

用new申请多个对象的指针销毁：

delete[] p2;
delete[] p4;

自定义类型：

先调用析构函数清理对象中的资源，再释放空间

#include<iostream>
using namespace std;
class A
{
public:
	A(int a=0)
	:_a(a)
	{}
	~A()
	{}
private:
	int _a;
};

int main()
{
	A* p1 = new A;
	A* p2 = new A(10);
	delete p2;
}

 结论：

1.内置类型new/delete和malloc/free没有本质的区别，只有用法的区别，new/delete更简便了；

2.new/delete是为自定义类型准备的，不仅在堆上申请出来，还调用构造函数和析构函数初始化和清理