C++的内存管理和模板

一、内存管理

1.内存的分布

这是在C语言中的内存分布，C++的内存分布也是这样。下面让我们看看C++中的动态内存开辟是什么样的吧。

2.C++中的动态内存管理

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

int main()
{
	int* ptr1 = new int;      //动态申请一个int类型的空间	
	char* cptr = new char;    //动态申请一个char类型的空间	
	int* ptr2 = new int(10);  //动态申请一个int类型的空间并初始化为10
	int* ptr3 = new int[10];  //动态申请10个int类型的空间
	delete ptr1;	//释放ptr1的空间
	delete cptr;	//释放ptr1的空间
	delete ptr2;	//释放ptr2的空间
	delete[] ptr3;	//释放ptr3的空间
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]。
操作案例：

class A
{
public:
	A(int a = 0) :a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int a;
};
int main()
{
	cout << "开始创建1个A类型的对象：" << endl;
	A* ptr1 = new A;
	cout << endl;
	cout << "开始创建3个A类型的对象：" << endl;
	A* ptr2 = new A[3];
	cout << endl;
	cout << "开始释放1个A类型的对象：" << endl;
	delete ptr1;
	cout << endl;
	cout << "开始释放3个A类型的对象：" << endl;
	delete[] ptr2;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

new/delete 和 malloc/free最大区别是 new/delete对于[自定义类型]除了开空间还会调用相应的构造函数和析构函数。而内置类型几乎一样。

3.重载new和重载delete

某些应用程序对内存分配有特殊的需求，因此我们无法将标准内存管理机制直接应用于这些程序，它们常常需要自定义内存分配的细节，比如使用关键字new将对象放置在特定的内存空间中。为了实现这一目的，应用程序需要重载new运算符和delete运算符以控制内存分配过程。
尽管我们说重载new和delete，但实际上重载这两个运算符和其他运算符重载大不相同。

int main()
{
	A* ptr1 = new A(10);//分配并初始化一个A对象
	A* ptr2 = new A[10];//分配10个默认初始化的A对象
	delete ptr1;//销毁 *ptr1，并释放ptr1指向的空间
	delete[] ptr2;//销毁数组中的元素，然后释放相应的空间
	return 0; 
}
1
2
3
4
5
6
7
8

`
上述代码实际执行三步操作：
1.new表达式调用一个名为 operator new(或者opreator new[])的标准库函数。该函数分配一块足够大的，原始的，未命名的内存空间以便存储特定对象（或者对象数组）。
2.编译器运行相应的构造函数以构造这些对象，并传入初始值。
3.对象被分配了空间并且完成了构造，返回一个指向该对象的指针。

上述代码实际执行两步操作：
1.对ptr1所指向的对象或者ptr2所指向的数组中的元素执行相应的析构函数。
2.编译器调用名为 operator delete(或者opreator delete[])的标准库函数进行释放空间。
总结：
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

这是在VS上找到的重载new和delete的函数原型。
通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，operator delete 最终是通过free来释放空间的。
注意：当自定义了全局的operator new 函数和operator delete函数后，我们就担负起了控制动态内存分配的职责。这两个函数必须是正确的，因为它们是程序整个处理过程中至关重要的一部分。

4.new和delete的实现原理

对于内置类型来说：new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
对于自定义类型类型来说：
new调用operator new函数申请空间，并且在申请的空间上执行构造函数，完成对象的构造。
new [ ] 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请，并且在申请的空间上执行构造函数，完成对象的构造。
delete先进行析构函数，完成对象中资源的清理工作，在调用operator delete函数释放对象的空间。
delete [ ]先进行相应次数的析构函数，完成对象中资源的清理工作， 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间。
注意：即使是底层调用的malloc和free，我们也不能使用new申请空间用free释放或者使用malloc申请空间使用delete释放。我们不可以混合使用，因为在一些特定的场景下会出现意想不到的结果。

5.定位new

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

new (place_address) type
new (place_address) type (initializers)
new (place_address) type [size]
new (place_address) type[size]{ barced initializer - list }
1
2
3
4

place_address必须是一个指针，同时在initializers中提供一个（可能未空的）以逗号分割的初始值列表，该初始值列表将用于构造新分配的对象。

int main()
{	
	//ptr现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* ptr = (A*)malloc(sizeof(A));  
	//注意：如果A类的构造函数有参数时，此处需要传参
	new(ptr)A;	
	ptr->~A();
	free(ptr);
	return 0;
}
1
2
3
4
5
6
7
8
9
10

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

二、模板

面对对象编程（OOP）和泛型编程都能处理在编写程序时不知道类型的情况。不同之处在于：OOP能处理类型在程序运行之前都未知的情况，而在泛型编程中，在编译时就能获知类型了。
尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

1.泛型编程

编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。一个模板就是一个创建类或函数的蓝图或者说公式

2.函数模板

1.定义模板

假如我们需要编写一个函数来比较两个值，并且指出实际的关系，在实际中，我们可能想要定义多个函数，通过函数重载来比较每一种类型。
例如：

int Compare(const int a,const int b)
{
	if (a < b)
	{
		return -1;
	}
	if (a == b)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}
int Compare(const char a, const char b)
{
	if (a < b)
	{
		return -1;
	}
	if (a == b)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}
int main()
{
	int a = 20;
	int b = 10;
	char cha = 'a';
	char chb = 'b';
	cout << Compare(a, b) << endl;
	cout << Compare(cha, chb) << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

当我们要比较浮点数在重载一个浮点数类型的比较，这样做太麻烦且逻辑一样，代码冗余。
函数模板格式：

template<typename T1, typename T2, ..., typename Tn>
返回值类型 函数名(参数列表) {}
1
2

下面我们把它改为模板来观察一下结果吧：

template<typename T>
int Compare(const T a, const T b)
{
	if (a < b)
	{
		return -1;
	}
	if (a == b)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}
int main()
{
	int a = 20;
	int b = 10;
	char cha = 'a';
	char chb = 'b';
	float fa = 1.25;
	float fb = 1.25;
	cout << Compare(a, b) << endl;
	cout << Compare(cha, chb) << endl;
	cout << Compare(fa, fb) << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

我们只是通过一个函数就解决了我们整形，字符和浮点型的比较。

2.实例化模板

当我们调用一个函数模板时，编译器（通常）用函数实参来为我们推断模板实参，当我们调用Compare时，编译器使用实参的类型来确定绑定到模板参数T的类型。
例如：

cout << Compare(a, b) << endl;//T的类型为int
1

我们的实际参数为int，编译器会推断出模板实参为int，并将它绑定到模板参数T，编译器用推断出的模板参数来为我们实例化一个特定版本的函数。

//实例化出int Compare(const int a, const int b)
cout << Compare(a, b) << endl;
//实例化出int Compare(const char a, const char b)
cout << Compare(cha, chb) << endl;
1
2
3
4

这些编译器生成的版本通常被称为模板的实例。

3.模板类型的参数

我们的Compare函数有一个模板类型参数，一般来说我们可以将类型参数看作类型说明符，就像内置类型或者类类型说明符一样使用。我们类型参数前必须要使用class或者typename。

template<typename T1,class T2>
int compare(const T1 a, const T2 b);
1
2

在模板参数列表中，这两个关键字的含义相同，可以互换使用，一个模板参数列表中可以同时使用这两个关键字。

4.非类型模板参数

除了定义类型参数，还可以在模板中定义非类型参数，一个非类型参数表示一个值而非一个类型。我们可以通过一个特定的类型名而非关键字class或者typename来指定非类型参数。
当一个模板被实例化时，非类型参数被第一个用户提供的或编译器推断出来的值所替代。这些值必须是常量表达式，从而允许编译器在编译时实例化模板。

template<unsigned N, unsigned M>
int comper(const char(&arr1)[N], const char(&arr2)[M])
{
	return strcmp(arr1, arr2);
}
int main()
{
	//实例化出int comper(const char(&arr1)[6], const char(&arr2)[5])
	comper("hello", "word");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

非类型模板参数的模板实参必须是常量表达式。

3.类模板

类模板是用来生成类的蓝图的。与函数模板不同的是，编译器不能为类模板推断模板类型参数。为了使用类模板我们必须在模板名后的尖括号中提供额外信息。

1.定义模板

类模板的定义格式：

template<class T1, class T2, ..., class Tn>
class 类模板名
{
	// 类内成员定义
};
1
2
3
4
5

例如：

template<class T1, class T2>
class A
{
public:
	A(){}
	A(T1 a, T2 b)
	{
		_a = a;
		_b = b;
	}
	void Geta()
	{
		cout << _a << endl;
	}
	void Getb()
	{
		cout << _b << endl;
	}
	~A();
private:
	T1 _a;
	T2 _b;
};
//类模板中函数放在类外进行定义时，需要加模板参数列表
template<class T1, class T2>
A<T1, T2>::~A()
{
	_a = 0;
	_b = 0;
}
int main()
{
	A<int, char> a(10,'a');
	a.Geta();
	a.Getb();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

注意：类模板中函数放在类外进行定义时，需要加模板参数列表。

2.实例化模板

我们已经看到，当我们使用一个类模板时，我们必须提供额外的信息。我们现在知道这些额外信息是显示模板实参列表，它们被绑定到模板参数，编译器使用这些模板实参来实例化出特定的类。
例如上面代码中

class A
{
public:
	A() {}
	A(int a, char b)
	{
		_a = a;
		_b = b;
	}
	void Geta()
	{
		cout << _a << endl;
	}
	void Getb()
	{
		cout << _b << endl;
	}
	~A()
	{
		_a = 0;
		_b = 0;
	}
private:
	int _a;
	char _b;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

一个类模板的每个实例都会形成一个独立的类。

3.模板的成员函数

与其他任何类相同，我们既可以在类模板内部定义成员函数，也可以在类模板外部定义成员函数，且定义在类模板内的成员函数被隐式声明为内敛函数。我们在上面已经见到了如何在类模板内部和类模板外部定义成员函数了。

总结

C++的内存申请与释放是我们后面的基础，模板则为我们了解容器有很深的作用，所以这两个需要我们重点学习。