c++中的内存管理-优快云博客

一.内存管理的定义：

类似于C语言中的动态内存开辟，c++中也相应的有内存管理，通过关键字new+类型来实现，返回值是对应类型的一个指针（与C语言中的void 类型不同）

二.new 的具体实现：

1.动态申请一个int类型的空间：

int* p1 = new int;

2.对该类型进行初始化：与C语言的不同，C语言中的malloc()不支持初始化，但是c++就能直接在后面用（）进行初始化

int* p1 = new int(1);

3.申请10个int类型的空间（数组）：

int* p2 = new int[10];

4.对该int类型的数组进行初始化：(对于内置类型，既可以完全初始化，也可以不完全初始化)

int* p2 = new int[10](1,2,3);

5.申请一个自定义类型A的对象：（有默认构造）

class A {
public:
	A(int a = 10,int b = 20)
		:_a(a),_b(b)
	{};
private:
	int _a;
	int _b;
};
int main() {
	A* p1 = new A;
	return 0;
}

6.对该自定义类型进行初始化：同样的，也是在后面用（）来进行你想要的初始化数据：

class A {
public:
	A(int a = 10,int b = 20)
		:_a(a),_b(b)
	{};
private:
	int _a;
	int _b;
};
int main() {
	A* p1 = new A(1,2);
	return 0;
}

7.申请10个自定义类型A的对象：（有默认构造）

class A {
public:
	A(int a = 10,int b = 20)
		:_a(a),_b(b)
	{};
private:
	int _a;
	int _b;
};
int main() {
	A* p1 = new A[10];
	return 0;
}

8.对该10个的自定义进行初始化就要注意了：不能用（）初始化，要用{ }来初始化。（既可以完全初始化，也可以不完全初始化）

class A {
public:
	A(int a = 10,int b = 20)
		:_a(a),_b(b)
	{};
private:
	int _a;
	int _b;
};
int main() {
	A* p1 = new A[10]{ {1,2},{3,4} };
	return 0;
}

9.但是，对于没有默认构造的自定义类型，就不能new 来申请空间，会直接报错。

原因是：

new 开辟空间会自动调用自定义类型的默认构造函数来初始化对象，如果没有默认构造，就不能初始化，所以编译器就会直接报错。（几个对象，就调用几次几次构造，10个对象就调用10次默认构造函数来为10个对象赋初值）

三.内存的释放：

c++中与new 关键字配套的是delete

1.释放一个new 申请的int 类型：

	int* p1 = new int;
	delete p1

2.释放10个int 的类型：注意加 [ ]

	int* p1 = new int[10];
	delete[] p1;

3.相似地，释放一个自定义类型A：

	A* p1 = new A;
	delete p1;

4.释放10个自定义A类型：也要加 [ ]

	A* p1 = new A[10];
	delete[] p1;

四.值得注意的几点：

@与C语言中的fre（）相似的delete,千万不要交叉使用，应按照如图对应的关系来使用。不然会造成报错。

@new 和delete 的本质是：

new = operator new + 默认构造

这就回答了，为什么没有默认构造的自定义类型用new 会报错，而对内置类型就不会报错，即使是内置类型，他也不会给初始值。如图，

@再一个就是，operator new 中的核心是malloc()函数，所以C++中的new只能是申请一块连续的空间，不能像C语言中的malloc、realloc、calloc这么的多样性。

delete = 析构函数 + operator delete

所以，对于自定义类型调用一次delete，就会调用该类型的析构函数