前言

🎃之前在使用C语言的时候，我们便使用 malloc 和 calloc 等函数进行动态内存的开辟。但 C++ 之中又引入了两个操作符 new 和 delete 来代替C语言中的函数进行动态内存的管理。下面就一起来学习如何使用吧。

1.new

🎃使用 new 比使用 malloc 方便许多，只需要 new+ 类型即可完成空间申请。而随着后面加的操作不同，能达到不一样的效果。

🎃不仅如此使用 new 之后不需要像 malloc 那样检查是否开辟成功，new 失败会自动抛异常(具体如何，以后再进行讲解)。

int main()
{
	int* p1 = new int;        //申请一个int大小的空间
	int* p2 = new int(3);     //申请一个int大小的空间并初始化成3
	int* p3 = new int[5];     //申请五个int大小的空间
    int* p4 = new int[5]{ 1,2,3,4,5 };  //申请五个int大小的空间并初始化
	return 0;
}

🎃虽然说 C++ 中同样支持使用C语言的 malloc ，但在有些情况下会显得有些捉襟见肘，比如以下代码：

class A                //定义类A
{
public:
	A(int a = 0, int b = 0)
		:_a(a)
		, _b(b)
	{}
private:
	int _a;
	int _b;
};

int main()
{
	A* p1 = new A(2, 3);   //用new动态开辟
	A* p2 = (A*)malloc(sizeof(A));  //用malloc动态开辟
	if (p2 == NULL)
	{
		perror("malloc");
		return 0;
	}
	return 0;
}

🎃通过调试我们可以看到，使用 new 开辟出来的空间是已经初始化好的，而使用 malloc 开辟的空间中则是随机值。

🎃这是由于 new 对于自定义类型会调用其构造函数进行对象的初始化。若一次申请 n 个对象的连续，便会调用 n 次构造函数进行初始化。

2.delete

🎃有开辟就有释放，delete 就是进行释放这个工作。只需要 delete 加空间的首指针便可完成释放，若释放多个对象的空间则需要使用 delete[ ]。

int main()
{
	int* p1 = new int;        //申请一个int大小的空间
	int* p2 = new int(3);     //申请一个int大小的空间并初始化成3
	int* p3 = new int[5];     //申请五个int大小的空间
	delete p1;                //正常申请空间则直接delete
	delete p2;
	delete[] p3;              //带[]申请则也需要用delete[]进行释放
	return 0;
}

🎃直接使用 delete[ ] ，没有告诉系统空间多大那系统是如何释放空间的呢？

🎃编译器在 new 的时候，若遇上多组开辟的情形时，会在开辟的空间前额外增加一个位置用于存储开辟空间的大小。

🎃根据上文推导，delete 应该会调用类的析构函数进行回收。我们可以使用下面的代码进行验证一下。

class A
{
public:
	A(int a = 7, int b = 8)
		:_a(a)
		, _b(b)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()";
	}
private:
	int _a;
	int _b;
};

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

🎃在当前代码中，只有使用了 delete 才会调用析构函数，而 free 只是单纯的释放空间。若在类之中再次进行动态开辟，而不调用析构函数进行回收时，便会出现内存泄漏。

class A
{
public:
	A(int a = 0, int b = 0)
		:_a(a)
		, _b(new int(b))
	{
		cout << "A()" << endl;
	}
	~A()
	{
		delete _b;
		cout << "~A()";
	}
private:
	int _a;
	int* _b;
};

int main()
{
	A* p1 = new A();
	return 0;
}

🎃若在平时的工程之中引发内存泄漏，便会降低代码的运行效率。因此切记，new 和 delete 必须要配合使用。

3.底层逻辑

🎃通过查看系统文档，我们便能够找到两个全局函数。

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
    // try to allocate size bytes
    void *p;
    while ((p = malloc(size)) == 0)
    if (_callnewh(size) == 0)
    {
        static const std::bad_alloc nomem;
        _RAISE(nomem);
    }
    return (p);
}

void operator delete(void* pUserData)
{
	_CrtMemBlockHeader* pHead;
	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
	if (pUserData == NULL)
		return;
	_mlock(_HEAP_LOCK); 
	__TRY
		pHead = pHdr(pUserData);
	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
	_free_dbg(pUserData, pHead->nBlockUse);
	__FINALLY
		_munlock(_HEAP_LOCK);
	__END_TRY_FINALLY
	return;
}

#define free(p) _free_dbg(p, _NORMAL_BLOCK)

🎃new 和 delete 是用户进行动态内存申请和释放的操作符，operator new 和 operator delete 是系统提供的全局函数，new 在底层调用 operator new 全局函数来申请空间，delete 在底层通过 operator delete 全局函数来释放空间。

🎃由上述的底层代码我们发现，operator new 实际也是通过 malloc 来申请空间，如果申请空间成功就直接返回，否则就抛异常。而operator delete 最终是通过 free 来释放空间的

🎃值得注意的是，operator new 和 operator delete 是系统提供的全局函数，并不是运算符重载，只是恰好与其用了相同的名字。

🎃new 和 delete 的本质上就是对 malloc 和 free 的封装。

🎃new 便是先开辟空间再调用构造函数，而 delete 则是先调用析构函数再释放空间。

4.定位new

🎃定位 new 表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

class A
{
public:
	A(int a = 0)
		:_a(a)
	{}
	~A()
	{}
private:
	int _a;
};

int main()
{
	A* p = (A*)malloc(sizeof(A));
	p = new(p)A;           //如果构造函数有参数则需要传参2
	return 0;
}

🎃这个操作一般是不会用到的，因为正常情况下我们直接使用 new 就能达到这个结果，没有必要特意 malloc 一次再使用 new 。真正需要使用定位 new 的情况是当我们从内存池中申请空间后，由于这种申请出来的空间是未初始化的，因此需要调用构造函数，所以使用定位new进行初始化。

5.对比

malloc 和 free是函数，new 和 delete 是操作符。
malloc 申请的空间不会初始化，new 可以初始化。
malloc 申请空间时，需要手动计算空间大小并传递，new 只需在其后跟上空间的类型即可，如果是多个对象，即在[ ]中指定对象个数。
malloc 的返回值为 void* , 在使用时必须强转，new 不需要。
malloc 申请空间失败时，返回的是 NULL ，因此使用时必须判空，new 不需要，new 失败则会进行抛异常。
申请自定义类型对象时，malloc/free 只会开辟和清理空间，不会调用构造函数与析构函数，而 new 在申请空间后会调用构造函数完成对象的初始化， delete 在释放空间前会调用析构函数完成空间中资源的清理。