C++:内存管理和模板

目录

前言：

一、new和deleta基本用法 

1.1 new/delete操作内置类型

1.2 new和delete操作自定义类型

1.3new和delete的实现原理

1.3.1operator new与operator delete函数

1.4定位new 

1.5 malloc/free和new/delete的区别

 二、模板

2.1泛型编程 

2.2函数模板 

2.2.1概念

2.2.1函数模板的原理 

2.2.3模板的实例化 

2.2.4模板参数的匹配原则

2.3类模板 

2.3.1类模板定义格式 

2.3.2 类模板的实例化

---

前言：

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

一、new和deleta基本用法 

1.1 new/delete操作内置类型

#include<iostream>
using namespace std;
void Test()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
    delete ptr4;
    //释放掉ptr4指向的堆内存的空间
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
    delete ptr5;
    //释放掉ptr5指向的堆内存的空间
	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];
	delete[] ptr6;
    //释放掉ptr6指向的堆内存的空间
}
int main()
{		
	Test();
	return 0;
}

 如下图程序：p是维护一个int类型的数组,数组中有10个元素，使用{}进行初始化，没有完全初始化的元素编译器默认用0初始化。对应需要用delete[]释放内存。

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

常遇问题：

对象泄露：使用new，但是忘记用delete释放掉分配的对象。

提前释放：在尚有其他指针指向该对象并且后续仍会使用该对象的情况下过早地delete。

重复释放：同一对象被释放两次，两次调用对象的析构函数（如果有的话）。

1.2 new和delete操作自定义类型

new/delete 和 malloc/free最大区别是 ：new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数 。

new的功能：1.开辟空间 2.调用构造函数

delete的功能：1.调用析构函数 2.释放空间

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
	// 内置类型是几乎是一样的
	int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int;
	free(p3);
	delete p4;

	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[10];
	free(p5);
	delete[] p6;
	return 0;
}

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

接下来看一个复杂的例子：

class stack {
public:
	stack(int capatity=4)
	{
		_a = new int[capatity];
		_top = 0;
		_capatity = capatity;
	}
	~stack()
	{
		delete[] _a;
		_a = nullptr;
		_top = 0;
		_capatity = 0;
	}
private:
	int* _a;
	int _top;
	int _capatity;
};
int main()
{
	stack* p = new stack;
	delete p;
}

1.3new和delete的实现原理

1.3.1operator new与operator delete函数

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

operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。

operator delete: 该函数最终是通过free来释放空间的。

实际上 operator new和operator delete的本质就是malloc和free！而new就是先调用operator new之后再调用构造函数，delete就是先调用析构函数再调用operator delete。

可以看到编译器先调用了operator new之后call(可以看做是跳转的汇编命令)的地址就是构造函数的地址 。使用delete会先调用析构函数，然后调用operator delete释放空间，这里就不展示了。

 而使用new[]时会先调用operator new[]，而operator new[]调用operator new去开辟空间 ，但是有一个问题是开辟的空间大小是124个字节。编译器多开辟了4个字节，用来存放对象的个数。

那么为什么要多开辟这4个字节呢？这就要和delete[]有关系了。我们发现delete[]中没有写析构对象的个数。那么它怎么知道我要析构对象的个数呢，可以想到通过将ptr指针减去4个字节就可以拿到要析构的对象个数，同时释放空间时也应当从ptr-4的位置开始释放，这就是我们最好配套使用new和delete、new[]和delete[]的原因。 

 

最后就是这里开辟空间只开辟一次，构造函数调用10次，析构函数调用10次。 

1.4定位new 

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

使用格式：new(指针)类型（初始化列表）这样我们就可以显示的调用构造函数了。

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

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);
	//相当于new
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	//相当于delete
	p2->~A();
	operator delete(p2);
	return 0;
}

1.5 malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：

1. malloc和free是函数，new和delete是操作符

2. malloc申请的空间不会初始化，new可以初始化

3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可

4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型

5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需

要捕获异常

6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

 二、模板

2.1泛型编程 

例子引入：如何实现一个通用的交换函数

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}
void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}

使用函数重载虽然可以实现，但是有一下几个不好的地方：

1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数2. 代码的可维护性比较低，一个出错可能所有的重载均出错。那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

2.2函数模板 

2.2.1概念

        函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。  

函数模板格式：

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

template<typename T>
void Swap( T& left, T& right)
{
    T temp = left;
    left = right;
    right = temp;
}

 

可以看到调用的两个Swap是不同的函数。 

 注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

2.2.1函数模板的原理 

    函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

        在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。 

2.2.3模板的实例化 

        用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

1. 隐式实例化：让编译器根据实参推演模板参数的实际类型

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.0, d2 = 20.0;
	Add(a1, a2);
	Add(d1, d2);
	/*
	该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
	通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
	编译器无法确定此处到底该将T确定为int 或者 double类型而报错
	注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
	Add(a1, d1);
	*/
	// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
	//Add(a1, (int)d1);
	return 0;
}

2.显式实例化：在函数名后的<>中指定模板参数的实际类型

int main(void)
{
    int a = 10;
    double b = 20.0;
    // 显式实例化
    Add<int>(a, b);
    return 0;
}

T* f(int n)
{
    T* P=new T[n];
    return p;
}
int main()
{
    //显式实例化
    double* d=f<double>(10);
    return 0;
}

2.2.4模板参数的匹配原则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

int Add(int left, int right)
{
	return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
	return left + right;
}
void Test()
{
	Add(1, 2); // 与非模板函数匹配，编译器不需要特化
	Add<int>(1, 2); // 调用编译器特化的Add版本
}

2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板 

int Add(int left, int right)
{
	return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
	return left + right;
}
void Test()
{
	Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
	Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

 3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换 

2.3类模板 

2.3.1类模板定义格式 

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

 举一个例子：

template<class T>
class stack {
public:
	stack(int capatity=4)
	{
		_a = new T[capatity];
		_top = 0;
		_capatity = capatity;
	}
	~stack()
	{
		delete[] _a;
		_a = nullptr;
		_top = 0;
		_capatity = 0;
	}
private:
	T* _a;
	int _top;
	int _capatity;
};
int main()
{
	stack<int> s1;//创建储存int类型的栈对象
    stack<double> s2;//创建储存double类型的栈对象
}

 类模板中声明和定义分离的成员函数：

template<class T>
class Vector
{
public:
	Vector(size_t capacity = 10)
		: _pData(new T[capacity])
		, _size(0)
		, _capacity(capacity)
	{}
	// 使用析构函数演示：在类中声明，在类外定义。
	~Vector();
	void PushBack(const T& data);
	void PopBack();
		// ...
		size_t Size() { return _size; }
	T& operator[](size_t pos)
	{
	assert(pos < _size);
	return _pData[pos];
	}
private:
	T*  _pData;
	size_t _size;
	size_t _capacity;
};
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{
	if (_pData)
		delete[] _pData;
	_size = _capacity = 0;
}
int main()
{
	Vector<int> a;
	return 0;
}

2.3.2 类模板的实例化

        类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类

// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;