new和delete

目录

一、基本用法

举例1：内置类型

举例2：自定义类型

举例3：对象数组初始化

二、new和delete的匹配使用

举例1：

不匹配导致出错：

正确：

三、operator new和operator delete

---

一、基本用法

 1.new 数据类型;//申请内存空间
 2.new 数据类型(初值);//申请内存空间，并指定初值
 3.new 数据类型[内存单元个数];//申请多个内存空间 

两种用法
1.delete a;//a是整型指针，释放单个int的空间
2.delete []b;//释放int数组空间 

举例1：内置类型

#include<iostream>
using namespace std;
int main()
{
	//自动计算大小，不需要强转
	int* p1 = new int;
	delete p1;

	int* p2 = new int(10);//初始化
	delete[] p2;

	int* p3 = new int[10];//多个对象
	delete[] p3;

	int* p4 = new int[10] {1, 2, 3};//后面7个没有初始化默认为0
	int* p5 = new int[10] {};//初始化默认为0

	delete[] p4;
	delete[] p5;

	return 0;
}

举例2：自定义类型

• new，开空间+构造函数初始化
• delste，调用析构函数+释放空间

#include<iostream>
class A
{
public:
	A(int a = 0):_a(a)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

int main()
{
	//malloc类型没有办法很好支持申请的自定义对象初始化
	A* p1 = (A*)malloc(sizeof(A));
	free(p1);


	//自定义类型，开空间+构造函数初始化
	A* p2 = new A;
	A* p3 = new A(4);

	//自定义类型，调用析构函数+释放空间
	delete p2;
	delete p3;
	return 0;
}

举例3：对象数组初始化

#include<iostream>
class A
{
public:
	A(int a = 0):_a(a)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

int main()
{
	A aa1(1);
	A aa2(2);
	A* p1 = new A[5]{ aa1,aa2 };//方式一：使用有名对象
	delete[] p1;

	A* p2 = new A[5]{ A(1),A(2) };//方式二：使用匿名对象
	delete[] p2;

	A* p3 = new A[5]{ 1,2};//方式三：使用隐式类型转换
	delete[] p3;
	return 0;
}

二、new和delete的匹配使用

举例1：

#include<iostream>
using namespace std;
int main()
{
	int* p1 = new int[10];
	delete[] p1;//此处也可采用delete p1，或是free(p1)
	            //因为是内置类型，new的时候不会调用构造函数，同样释放的时候，不会调用析构
	return 0;
}

不匹配导致出错：

 

正确：

#include<iostream>
class A
{
public:
	A(int a = 0):_a(a)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

int main()
{
	A* p1 = new A[3];
	delete[] p1;
	return 0;
}

三、operator new和operator delete

• operator new 和operator delete是系统提供的全局函数
• new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
• operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的

#include<iostream>
class A
{
public:
	A(int a = 0):_a(a)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

int main()
{
	A* p1 = (A*)operator new(sizeof(A));//operator new其实是封装的malloc，因此此处不会调用构造函数
	operator delete(p1);

	A* p2 = new A;
	delete p2;
	return 0;
}