• C++模板初阶

    本节目标

    1.泛型编程

    如何实现一个通用的交换函数呢？

    void Swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}

void Swap(double& left, double& right)
{
	double tmp = left;
	left = right;
	right = tmp;
}

void Swap(char& left, char& right)
{
	char tmp = left;
	left = right;
	right = tmp;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    使用函数重载虽然可以实现，但是有几个不好的地方：
    1.重载的函数仅仅是类型不同，代码复用率比较低，只要有新的类型出现时，就需要用户增加对应的函数
    2.代码的可维护性比较低，一个出错可能所有的重载均出错

    那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？
    在这里插入图片描述
    如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料（类型），来获得不同材料的铸件（即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。

    模板 - - - （函数模板 类模板）

    2.函数模板

    2.1 函数模板概念

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

    2.2 函数模板格式

    template
    返回值类型 函数名（参数列表）{}

    void Swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}

void Swap(double& left, double& right)
{
	double tmp = left;
	left = right;
	right = tmp;
}

void Swap(char& left, char& right)
{
	char tmp = left;
	left = right;
	right = tmp;
}

//泛型编程 -- 模板
//模板参数（模板类型） -- 类似函数参数（参数对象）
//typename后面类型名字T是随便取的，Ty,K,V,一般大写字母或者单词首字母大写
//T 代表是一个模板类型（虚拟类型）
//template
template<typename T>    
void Swap(T& left, T& right)
{
	T tmp = left;
	left = right;
	right = tmp;
}


int main()
{
	int i = 1, j = 2;
	double x = 1.1, y = 2.2;
	Swap(i, j);
	Swap(x, y);


	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
    • 41
    • 42
    • 43
    • 44
    • 45

    注意：typename是用来定义模板参数的关键字，也可以使用class切记：不能使用struct代替class。
    这里Swap的调用顺序，如果有相应的函数就调用相应的函数，如果没有，则调用函数模板生成特定具体类型的函数调用。
    当然对于swap函数，其实库里就有。

    2.3 函数模板原理

    本质：重复的工作交给了机器去完成。

    函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来我们做的事情交给了编译器。
    在这里插入图片描述
    在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用·double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

    2.4 函数模板的实例化

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

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

    template<class T>
T Add(const T& x, const T& y)
{
	return x + y;
}

int main()
{
	int i = 1, j = 2;
	double x = 1.1, y = 2.2;
	//Swap(i, j);
	//Swap(x, y);

	Add(i, j);
	Add(x, y);

	/*
	该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
	通过实参i将T推演为int，通过实参x将T推演为double类型，但模板参数列表中只有一个T，
	编译器无法确定此处到底该将T确定为int 或者 double类型而报错
	注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
	Add(i, x);
	*/

	// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
	Add(i, (int)x);

	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

    2.显式实例化：在函数名的<>指定模板参数的实际类型。
    在这里插入图片描述
    在这里插入图片描述

    2.5模板参数匹配原则

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

    // 专门处理int的加法函数
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版本
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

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

    // 专门处理int的加法函数
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函
数
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

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

    3.类模板

    类模板是一个类家族，模板类是类模板实例化的具体类，并且类模板的成员函数都是模板函数。

    3.1类模板的定义格式

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


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    typedef int SLDateType;
class Stack
{
private:
	SLDateType* next;
	int top;
	int capacity;
};

class Stacki
{
private:
	int* next;
	int top;
	int capacity;
};

class Stackc
{
private:
	char* next;
	int top;
	int capacity;
};

int main()
{
	//这里我们想第一个栈内存int类型的数据
	//第二个栈内存char类型的数据，但这里无法实现
	Stack st;//int
	Stack st;//char

	//可以这样
	Stacki st;//int
	Stackc st;//char

	//但是这样会有一个麻烦，如果类型多的话，代码显得冗余
	//如何简化，类是否也可以像函数一样用模板来实现呢？
	//答案是可以的,见下面代码

	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
    • 41
    • 42
    • 43
    • 44

    3.2类模板实例化

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

    template <typename T>
class Stack
{
public:
	Stack(size_t capacity = 4)
		:_a(nullptr)
		, _top(0)
		, _capacity(capacity)
	{
		if (capacity > 0)
		{
			_a = new T[_capacity];
		}
	}

	~Stack()
	{
		delete[] _a;
		_a = nullptr;
		_top = _capacity = 0;
	}

	void Push(const T& x)
	{
		if (_top == _capacity)
		{
			//1.开空间
			//2.拷贝数据
			//3.释放旧空间
			size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
			T* tmp = new T[newCapacity];
			if (_a)
			{
				memcpy(tmp, _a, sizeof(T)*_top);
				delete[] _a;
			}

			_a = tmp;
			_capacity = newCapacity;
		}

		_a[_top] = x;
		_top++;
	}

	void Pop()
	{
		assert(_top > 0);
		_top--;
	}

	bool Empty()
	{
		return _top == 0;
	}
	 const T& Top()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}

private:
	T* _a;
	size_t _top;
	size_t _capacity;
};

int main()
{
	try
	{
		//类模板都是显式实例化
		//虽然他们用了一个类模板，但是Stack,Stack是两个类型
		
		//Stack st1; //int
		//Stack st2; //char

		我要知道我要存100个数据，避免插入时扩容消耗
		//Stack st3(100);
		//Stack st4(0);

		//Stack st5;

		Stack<int> st1;
		st1.Push(1);
		st1.Push(2);
		st1.Push(3);
		st1.Push(4);

	/*	st1.Top()++; //加了const就不能用了
		st1.Top() *= 2;*/

		while (!st1.Empty())
		{
			cout << st1.Top() << " ";
			st1.Pop();
		}
		cout << endl;

	}
	catch (const exception& e)
	{
		cout << e.what() << 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
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108

    模板不支持分离编译，声明放在.h，定义放在.cpp – 原因：模板进阶再讲解

    模板在同一个文件中，是可以声明和定义分离的

    template <typename T>
class Stack
{
public:
	Stack(size_t capacity = 4)
		:_a(nullptr)
		, _top(0)
		, _capacity(capacity)
	{
		if (capacity > 0)
		{
			_a = new T[_capacity];
		}
	}

	~Stack()
	{
		delete[] _a;
		_a = nullptr;
		_top = _capacity = 0;
	}

	void Push(const T& x);

	void Pop()
	{
		assert(_top > 0);
		_top--;
	}

	bool Empty()
	{
		return _top == 0;
	}
	 const T& Top()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}

private:
	T* _a;
	size_t _top;
	size_t _capacity;
};

template<class T>
void Stack<T>::Push(const T& x)
{
	if (_top == _capacity)
	{
		//1.开空间
		//2.拷贝数据
		//3.释放旧空间
		size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
		T* tmp = new T[newCapacity];
		if (_a)
		{
			memcpy(tmp, _a, sizeof(T)*_top);
			delete[] _a;
		}

		_a = tmp;
		_capacity = newCapacity;
	}

	_a[_top] = x;
	_top++;
}

    • 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
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
  • 相关阅读:
    xilinx zynq7系列加载器无法连接的原因&测试xilinx Zynq7开发板的加载器和芯片是否正常的快速方法
    技术的新浪潮：从SOCKS5代理到跨界电商的未来
    FPGA计数器边界问题解析
    Tomcat 发布项目 conf/Catalina/localhost 配置
    C++11、17、20的内存管理-指针、智能指针和内存池从基础到实战（上）
    Luckysheet 实现excel多人在线协同编辑
    前端简单的爱心形状
    【vue】html页面怎么设置页签图标？比如B站是个小电视的图标的效果
    文件操作~
    【洛谷 P3613】【深基15.例2】寄包柜 题解（映射）
  • 原文地址：https://blog.csdn.net/m0_55283616/article/details/126578648