C++ 对象动态建⽴和释放 new 和 delete

在开发过程中，常常需要动态地分配和撤销内存空间，例如对动态链表中结点的插入与删除。在C语言中是利用库函数malloc和free来分配和撤销内存空间的。C++提供了较简便而功能较强的运算符new和delete来取代malloc和free函数。

在C++中因为new和delete是运算符，不是函数，因此执行效率高。

虽然为了与C语言兼容，C++仍保留malloc和free函数，建议不用malloc和free函数，而用new和delete运算符。

new int; // 开辟⼀个存放整数的存储空间，返回⼀个指向该存储空间的地址(即指针)	
				
new int(100); // 开辟⼀个存放整数的空间，并指定该整数的初值为100，返回⼀个指向该存储空间的地址		
				
new char[10]; // 开辟⼀个存放字符数组(包括10个元素)的空间，返回⾸元素的地址		
				
new int[5][4];	// 开辟⼀个存放⼆维整型数组(⼤⼩为5*4)的空间，返回⾸元素的地址		
				
float *p = new float(3.14159); // 开辟⼀个存放单精度数的空间，并指定该实数的初值为//3.14159，将返回的该空间的地址赋给指针变量p		

#include <iostream>
#include <cstdlib>

using namespace std;

class Test{
	public:
		Test(){
			m_a = 0;
			m_b = 0;
			cout << "0，0 构造" << endl;
		}
		
		Test(int a, int b){
			m_a = a;
			m_b = b;
			cout << "a = " << m_a << ", b = " << m_b << "构造 " << endl;
		}
	
		void setA(int a){
			m_a = a;
		}
		
		void setB(int b){
			m_b = b;
		}
	
		void printT(){
			cout << "a = " << m_a << ", b = " << m_b << endl;
		}
	
		~Test(){
			cout << "a = " << m_a << ", b = " << m_b << "析构 " << endl;
		}
		
	private:
		int m_a;
		int m_b;
};


//C语言中
void test1(){
	
	int* p = (int*)malloc(sizeof(int));
	*p = 10;
	
	cout << *p << endl;
	
	if (p != NULL) {
		free(p);
		//delete p; //delete 可以释放malloc的开辟的内存
	}

	int* array_p = (int*)malloc(sizeof(int) * 10);
	for (int i = 0; i < 10; i++) {
		array_p[i] = i + 10;
	}

	for (int i = 0; i < 10; i++) {
		cout << array_p[i] << endl;
	}

	if (array_p != NULL) {
		free(array_p);
	}


	cout << " --------  " << endl;

	Test* tp = (Test*)malloc(sizeof(Test)); //不会调用对象的构造函数
	//p(10, 20);
	tp->setA(10);
	tp->setB(20); //malloc出来的对象指针，只能够通过成员函数来进行初始化
	tp->printT();

	if (tp != NULL) {
		free(tp); //不会调用对象的析构
	}
}

//malloc 和free 在对于普通变量是可以混合使用的，但是malloc和free是函数，
//new 和delete 是操作符。不是一个函数。

//C++中的new delete
void test2(){
	//new 能够完成所有malloc的需求
	int* p = new int; //在堆上动态开辟4个字节
	*p = 10;
	cout << *p << endl;

	if (p != NULL) {
		//delete p; //delete 一个变量
		free(p); //用new开辟的内存， free也能够释放。
	}

	cout << "-----" << endl;

	int* array_p = new int[10];
	for (int i = 0; i < 10; i++) {
		array_p[i] = i + 10;
	}
	for (int i = 0; i < 10; i++) {
		cout << array_p[i] << endl;
	}

	if (array_p != NULL) {
		delete[]   array_p; //delete 一个数组  // delete 数组的时候，虽然[]可以省略，程序运行的时候会自动处理和优化，但是为了方便代码的阅读，在delete数组的时候，需要在delete后面加上 []
	}


	cout << "-------" << endl;
	//Test *tp = new Test(10, 20);//调用了有参数的构造函数 //new 在创建一个对象的时候，会调用对象的构造函数
	Test* tp = new Test;//调用了无参构造函数
	tp->printT();
	if (tp != NULL) {
		delete tp; //delete在释放一个对象指针的时候，会调用对象析构函数
		tp = NULL;
	}
}

int main(void){
	//test1();
	test2();

	return 0;
}

• new 运算符动态分配堆内存
  使用形式：

  指针变量 = new 类型(常量);
  指针变量 = new 类型[表达式];

作用：从堆分配一块“类型”大小的存储空间，返回首地址
其中：“常量”是初始化值，可缺省创建数组对象时，不能为对象指定初始值

• delete 运算符释放已分配的内存空间
  使用形式：

  delete 指针变量;
  delete[] 指针变量;

其中：“指针变量”必须是一个 new 返回的指针

---

注：

用new分配数组空间时不能指定初值。如果由于内存不足等原因而无法正常分配空间，则new会返回一个空指针NULL，用户可以根据该指针的值判断分配空间是否成功。

总结：

• malloc不会调用类的构造函数,而new会调用类的构造函数
• free不会调用类的析构函数，而delete会调用类的析构函数