C++:new的用法_c++ new

new的三种用法

1.new operator（初始化对象=申请内存空间+内存定位）

例如：

//新建一个int类型数组，里面有5个元素
int * p_array = new int[5]{1,2,3,4,5};
//释放内存
delete [] p_array 

编译器执行顺序：

 
（1）先计算大小，为int类型，有5个则为20个字节
（2）从内存中开辟20个字节空间大小
（3）把这个空间初始化为1,2,3,4,5
（4）把这个空间的地址赋值给p_array

例如：

//新建一个int类型数据，初始值为5
int* p_val =new int(5);
//释放
delete p_val

2.operator new（仅申请内存空间）

new只申请内存空间，相当于malloc，delete相当于free

例如：

int *p  =(int *) ::operator new (sizeof(int));
int *p1 =(int *) ::operator new int(5);
 
delete p;
delete p1;

编译器处理流程：

（1）需要手动计算字节大小
（2）没有办法初始化
（3）返回的地址为void * 类型，需要自己手动强转
（4）内置类型使用函数方法

3.placement new（内存定位）

        定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。换句话说就是，现在空间已经有了，不需要定位new像常规new一样去给申请空间，只需要定位new在已有的空间上调用构造函数构造对象而已。

1）使用格式

1.new (place_address) type 
2.new (palce_address) type (initializer_list)

2）例如

#include <iostream>
#include <string>
#include <new>
using namespace std;
 
const int BUF = 512;
class JustTesting 
{
private:
	string words;
	int number;
public:
	JustTesting(const string& s = "Just Testing", int n = 0) {
		words = s;
		number = n;
		cout << words << " constructed" << endl;
	}
	~JustTesting() { cout << words << " destroyed!" << endl; }
	void Show()const { cout << words << " , " << number << endl; }
};
 
int main() {
	char* buffer = new char[BUF];//常规new在堆上申请空间
 
	JustTesting* pc1, * pc2;
 
	pc1 = new (buffer) JustTesting;//定位new
	pc2 = new JustTesting("Heap1", 20);//常规new
 
	cout << "buffer addr: " << (void*)buffer <<endl;
	cout << "pc1 addr: " << pc1 << "  show: ";
	pc1->Show();
	cout << "pc2 addr：" << pc2 << "  show: ";
	pc2->Show();
 
	JustTesting* pc3, * pc4;
	pc3 = new (buffer)JustTesting("Bad Idea", 6);//定位new
	pc4 = new JustTesting("Heap2", 10);//常规new
 
	cout << "pc3 addr：" << pc3 << "  show: ";
	pc3->Show();
	cout << "pc4 addr：" << pc4 << "  show: ";
	pc4->Show();
 
	cout << "pc2 addr：";
	delete pc2;//释放pc2申请的空间
	cout << "pc4 addr：";
	delete pc4;//释放pc4申请的空间
	cout << "buffer：";
	delete[] buffer;//释放buffer指向的空间
	cout << "Done!" << endl;
	return 0;
}

执行结果：

Just Testing constructed
Heap1 constructed
buffer addr: 0xe25e70
pc1 addr: 0xe25e70  show: Just Testing , 0
pc2 addr：0xe27090  show: Heap1 , 20
Bad Idea constructed
Heap2 constructed
pc3 addr：0xe25e70  show: Bad Idea , 6
pc4 addr：0xe270c0  show: Heap2 , 10
pc2 addr：Heap1 destroyed!
pc4 addr：Heap2 destroyed!
buffer：Done!

执行结果分析

Just Testing constructed  //定位new在内存缓冲区构造了一个新的对象pc1
Heap1 constructed  //常规new在堆上申请空间，构造第二个对象调用构造函数pc2
buffer addr: 0xe25e70  //常规new在堆上申请了内存空间，buffer内存地址
pc1 addr: 0xe25e70  show: Just Testing , 0 //pc1地址和buffer地址相同
pc2 addr：0xe27090  show: Heap1 , 20  //pc1和pc2地址不同
Bad Idea constructed //定位new在内存缓冲区构造了一个新的对象pc3
Heap2 constructed //常规new在堆上申请空间，构造第二个对象调用构造函数pc4
pc3 addr：0xe25e70  show: Bad Idea , 6 //pc1、pc3 与buffer地址相同
pc4 addr：0xe270c0  show: Heap2 , 10//pc4与pc1、pc2、pc3地址不同
pc2 addr：Heap1 destroyed!//pc2析构
pc4 addr：Heap2 destroyed!//pc4析构
buffer：Done!//buffer析构
 
 

执行结果进一步分析：

（1）在使用delete回收空间时，可以发现并未回收pc1与pc3，其原因在于pc1与pc3指向的对象位于内存缓冲区，该空间并不是定位new申请，而是常规new申请的，因此我们需要delete[]回收内存缓冲区，而不是delete pc1与delete pc3

（2）pc1与pc3一致，说明第一个对象被第三个覆盖！显然，如果类动态地为其成员分配内存，这将引发问题！，所以，当我们使用定位new创建对象必须自己保证不会覆盖任何不想丢失的数据！，就这个例程而言，避免覆盖，最简单的做法如下：

pc1 = new (buffer) JustTesting;
pc3 = new (buffer + sizeof(JustTesting)) JustTesting("Better Idea!",6);

（3）delete[] buffer并未引发对象的析构！，虽然对象1及3的空间被回收，但对象1与3并未析构！这一点将时刻提醒我们使用定位new需要自己显式调用析构函数，完成对象的析构！，但该析构并不能通过delete pc1或delete pc3实现！（因为delete与定位new不能配合使用！，否则会引发运行时错误！），只能通过显式析构，如下：

pc3->~JustTesting();
pc1->~JustTesting();

参考连接：

浅谈定位new_明月本无心的博客-CSDN博客

 new的三种用法_new的用法_乐十九的博客-CSDN博客

c++ new的三种用法 【由基础到进阶 】_c++new的用法_long~w的博客-CSDN博客