c++模板全覆盖

  模板初阶

 泛型编程

1.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什么是泛型编程

核心思想是编写可重用的组件（如算法或数据结构）

编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同 材料的铸件(即生成具体类型的代码）

---

2. 函数模板

2.1 函数模板概念 

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

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;
}

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

2.3 函数模板的原理

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

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

2.4 函数模板的实例化

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

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(a, (int)d);
    return 0;
}

2. 显式实例化

：在函数名后的<>中指定模板参数的实际类型

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

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

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版本
 }

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函数
 }

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

3. 类模板

3.1 类模板的定义格式

template<typename T1, typename T2, ..., typename Tn> 
//tmplate<class T1, class T2,.....,class Tn> 表示相同
class 类模板名
{
 // 类内成员定义
}; 

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

3.2 好处

1.用来在一个类中可以建立两种不同类型的类，不用写两遍

using namespace std;
template<typename T>
class Stack
{
public:
	Stack(size_t capacity=4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};
int main()
{
	Stack<int> st1;    //int
	Stack<double> st2; // double
	return 0;
}

3.3写法要求（语法要点）

1当声明与定义分离时，只能在类中定义

且在类外就要在定义一遍

using namespace std;
template<typename T>
class Stack
{
public:
	Stack(size_t capacity=4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
	void Push(const T& data);
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};
template<class T>
void Stack<T>::Push(const T& data)
{
	// 扩容
	_array[_size] = data;
	++_size;
}

3.2 类模板的实例化

只能显示实例化

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

模板进阶

1.非类型模板参数

模板参数分类类型形参与非类型形参。

类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。

非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常 量来使用。

#include <iostream>
namespace bite
{
    // 定义一个模板类型的静态数组
    template<class T, size_t N = 10>
    class array
    {
    public:
        T& operator[](size_t index) { return _array[index]; }
        const T& operator[](size_t index) const { return _array[index]; }

        size_t size() const { return N; }
        bool empty() const { return 0 == N; }

    private:
        T _array[N];
    };
}

int main()
{
    // 实例化一个存储 int 类型、大小为 5 的数组
    bite::array<int, 5> intArray;
    // 实例化一个存储 double 类型、使用默认大小 10 的数组
    bite::array<double> doubleArray;

    std::cout << "intArray size: " << intArray.size() << std::endl;
    std::cout << "doubleArray size: " << doubleArray.size() << std::endl;

    return 0;
}

相比于宏的好处 

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。

2. 非类型的模板参数必须在编译期就能确认结果。

 2. 模板的特化

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些 错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
	return left < right;
}
int main()
{
	cout << Less(1, 2) << endl;   // 可以比较，结果正确
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 8);
	cout << Less(d1, d2) << endl;  // 可以比较，结果正确
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl;  // 可以比较，结果错误
	return 0;
}

 可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示 例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内 容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。 此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方 式。模板特化中分为函数模板特化与类模板特化。

2.2 函数模板特化

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3.  函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇 怪的错误。

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
	return left < right;
}
// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}
int main()
{
	cout << Less(1, 2) << endl;
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 8);
	cout << Less(d1, d2) << endl;
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl;  // 调用特化之后的版本，而不走模板生成了
	return 0;
}

注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该 函数直接给出。

bool Less(Date* left, Date* right)
{
 return *left < *right;
}

该种实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化 时特别给出，因此函数模板不建议特化。

2.3 类模板特化

2.3.1 全特化

全特化即是将模板参数列表中所有的参数都确定化。

template<class T1, class T2>
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};
template<>
class Data<int, char>
{
public:
	Data() { cout << "Data<int, char>" << endl; }
private:
	int _d1;
	char _d2;
};
void TestVector()
{
	Data<int, int> d1;
	Data<int, char> d2;
}

 2.3.2 偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。比如对于以下模板类：

template<class T1, class T2>
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

偏特化有以下两种表现方式：

部分特化

将模板参数类表中的一部分参数特化。

// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
	Data() { cout << "Data<T1, int>" << endl; }
private:
	T1 _d1;
	int _d2;
};

 参数更进一步的限制

偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一 个特化版本。

//两个参数偏特化为指针类型 
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
	Data() { cout << "Data<T1*, T2*>" << endl; }

private:
	T1 _d1;
	T2 _d2;
};
//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:
	Data(const T1& d1, const T2& d2)
		: _d1(d1)
		, _d2(d2)
	{
		cout << "Data<T1&, T2&>" << endl;
	}

private:
	const T1& _d1;
	const T2& _d2;
};
void test2()
{
	Data<double, int> d1;      // 调用特化的int版本
	Data<int, double> d2;      // 调用基础的模板    
	Data<int*, int*> d3;       // 调用特化的指针版本
	Data<int&, int&> d4(1, 2);  // 调用特化的指针版本
}

 2.3.3 类模板特化应用示例

有如下专门用来按照小于比较的类模板Less：

#include<vector>
#include<algorithm>
template<class T>
struct Less
{
	bool operator()(const T& x, const T& y) const
	{
		return x < y;
	}
};
int main()
{
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 6);
	Date d3(2022, 7, 8);
	vector<Date> v1;
	v1.push_back(d1);
	v1.push_back(d2);
	v1.push_back(d3);
	// 可以直接排序，结果是日期升序
	sort(v1.begin(), v1.end(), Less<Date>());
	vector<Date*> v2;
	v2.push_back(&d1);
	v2.push_back(&d2);
	v2.push_back(&d3);

	// 可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序
	// 此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象
	// 但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期
	sort(v2.begin(), v2.end(), Less<Date*>());
	return 0;
}

通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果是正确的。但是如果待排 序元素是指针，结果就不一定正确。因为：sort最终按照Less模板中方式比较，所以只会比较指 针，而不是比较指针指向空间中内容，此时可以使用类版本特化来处理上述问题：

// 对Less类模板按照指针方式特化
template<>
struct Less<Date*>
{
	bool operator()(Date* x, Date* y) const
	{
		return *x < *y;
	}
};

特化之后，在运行上述代码，就可以得到正确的结果

---

3.编译链接过程

1. 预处理：准备食材和调料

对应操作：展开头文件、处理宏定义、删除注释
输入文件：.h头文件 + .cpp源码

输出文件：.i预处理文件

// a.h
#define MAX 10  // 宏定义
// a.cpp
#include "a.h"  // 头文件
int main() { 
    int arr[MAX]; // 使用宏
    return 0; 
}

预处理后（a.i）：

// 展开头文件内容，替换宏
int main() {
    int arr[10]; // MAX被替换为10
    return 0;
}

预处理后的文件已去除注释，宏和头文件被实际内容替代。  

---

2. 编译：将食材加工成半成品 

对应操作：语法检查、生成汇编代码
输入文件：.i预处理文件
输出文件：.s汇编文件

实例转换：
预处理后的C++代码 → 汇编指令（以x86为例）：

编译器检查语法错误，并将高级代码转为低级汇编指令。

---

3. 汇编：将半成品加工成标准化零件

对应操作：将汇编代码转为机器码
输入文件：.s汇编文件
输出文件：.o目标文件0（.o也叫.obj 目标文件 object）

实例转换：
汇编代码 → 二进制机器码（十六进制表示）：

此时生成的目标文件已是二进制，但无法单独运行（类似未组装的汽车零件）

---

4. 链接：组装所有零件并测试

对应操作：合并目标文件、解析函数地址
输入文件：多个.o文件 + 库文件
输出文件：.out或.exe可执行文件

实例场景：

• a.cpp 调用 test.cpp 中的函数 void print()

• 编译后生成 a.o 和 test.o

链接过程：

1. 合并代码：将 a.o 和 test.o 的二进制合并

2. 地址解析：找到 print() 函数在内存中的实际地址

3. 库文件绑定：链接标准库（如C++的 libstdc++.so）

最终生成 a.out，双击即可运行程序。

 

---

4. 模板分离编译

什么是分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有 目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

// add.h（声明）
template<typename T>
T add(T a, T b); // 只有声明，没有实现！

// add.cpp（定义）
template<typename T>
T add(T a, T b) { return a + b; } // 实现藏在.cpp里

// main.cpp
#include "add.h"
int main() {
    add(2, 3); // 调用add<int>
    add(2.0, 3.0);
}

会出现这个链接错误。

 为什么函数模板分离声明和定义会链接错误？

1. 简单错误例子：

// add.h（声明）
template<typename T>
T add(T a, T b); // 只有声明，没有实现！

// add.cpp（定义）
template<typename T>
T add(T a, T b) { return a + b; } // 实现藏在.cpp里

// main.cpp
#include "add.h"
int main() {
    add(2,3); // 调用add<int>
    add(2.0,3.0); // 调用add<doudle>
}

2. 问题出在哪里？

• 模板的特殊性：模板不是真正的函数，而是“生成函数的模具”。

  • 只有当你用add<int>时，编译器才会用这个模具实例化一个int版本的函数。

  • 以下add<boudle>同理

• 编译main.cpp时：

1. 看到add(2, 3)，知道需要add<int>。
2. 但add.h只有声明，没有实现，所以无法实例化add<int>！
3. main.o的符号表会记录：需要add<int>（但找不到实现）。

• 编译add.cpp时：

  1. 虽然有模板实现，但add.cpp里没有代码调用add<int>！

  2. 所以编译器不会实例化add<int>，add.o的符号表里根本没有add<int>。

• 链接时：

  1. main.o需要add<int>，但所有.o文件里都找不到它。

  2. 报错：undefined reference to add<int>（找不到add<int>的定义）。

3. 根本原因：

• 模板实例化是“需要时才生成”：

  • 普通函数：编译时直接生成，链接时只需拼地址。

  • 函数模板：只有看到具体调用（如add<int>）且能看到定义时，才会实例化。

• 分离编译时：

  • main.cpp看不到模板定义，无法实例化。

  • add.cpp不知道你需要add<int>，也不会实例化。

4. 解决方案：

方法1：定义和声明都放在头文件（推荐）

// add.h
template<typename T>
T add(T a, T b) { return a + b; } // 声明和实现在一起

这样main.cpp包含add.h时，看到add<int>的调用，能当场实例化。

方法2：显式实例化（不推荐）

// add.cpp
template int add<int>(int, int); // 强制实例化int版本
template int add<double>(double, double); // 强制实例化double版本

 普通函数 vs 函数模板的对比

特性	普通函数	函数模板
定义位置	声明在.h，定义在.cpp	必须把定义放在头文件（推荐）
实例化时机	编译时直接生成函数	调用时且看到定义才会实例化
链接错误	忘记定义或声明不匹配	定义不可见导致无法实例化

 模板总结

【优点】

1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生

2. 增强了代码的灵活性

【缺陷】

1. 模板会导致代码膨胀问题，也会导致编译时间变长

 2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误