在C语言中,我们使用 malloc / calloc / realloc / free 动态管理内存。虽然C语言内存管理方式在C++中可以继续使用,但有些地方却无能为力,而且使用起来比较麻烦,因此C++又提出了自己的内存管理方式:通过 new/delete 操作符进行动态内存管理。
基础用法(操作内置类型)
new 和 delete 是搭配使用的。
#include<iostream>
using namespace std;
void test()
{
//动态申请一个int类型的空间
int* p1 = new int;
//动态申请一个int类型的空间,并初始化为1
int* p2 = new int(1);
//动态申请10个int类型的空间
int* p3 = new int[10] {0};
//释放空间
delete p1;
delete p2;
//释放多个内存空间要加[],搭配使用
delete[] p3;
}
int main()
{
test();
return 0;
}
操作自定义类型
new/delete 可以操作内置类型,但其用处更多在于操作自定义类型。
#include<iostream>
using namespace std;
class A
{
public:
A(int a1 = 1, int a2 = 1)
:_a1(a1)
, _a2(a2)
{
cout << "A(int a1 = 1, int a2 = 1)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a1;
int _a2;
};
int main()
{
//缺省函数初始化
A* p1 = new A;
A* p2 = new A();
//自定义初始化
A* p3 = new A(2, 2);
delete p1;
delete p2;
delete p3;
return 0;
}
同样,我们还可以一次定义多个。
#include<iostream>
using namespace std;
class A
{
public:
A(int a1 = 1, int a2 = 1)
:_a1(a1)
, _a2(a2)
{
cout << "A(int a1 = 1, int a2 = 1)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a1;
int _a2;
};
int main()
{
A* p1 = new A[10];
delete[] p1;
return 0;
}
自定义类型的类在调用时,除了会申请空间,还会在 new 时调用构造函数,在 delete 时调用析构函数。而 malloc/free 则不会。
#include<iostream>
using namespace std;
class A
{
public:
A(int a1 = 1, int a2 = 1)
:_a1(a1)
, _a2(a2)
{
cout << "A(int a1 = 1, int a2 = 1)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a1;
int _a2;
};
int main()
{
A* p3 = new A(2, 2);
A* p4 = new A[3];
delete p3;
delete[] p4;
return 0;
}
该程序会调用五次构造和析构函数。
operator new 函数和 operator delete 函数
new 和 delete 是进行动态申请和释放的操作符,operator new 函数和 operator delete 函数是系统提供的两个全局的函数,new 在底层调用 operator new 全局函数来申请空间,delete 在底层通过 operator delete 全局函数来释放空间。
但实际上,operator new 也是通过malloc来申请空间,如果 malloc申请空间成功就直接返回,否则执行用户提供的空间不足应对措施,如果用户提供该措施 就继续申请,否则就抛异常。operator delete 最终是通过free来释放空间的。
所以说 new/delete 最终还是通过 malloc/free 来实现的。