【C++模板编程】：从初阶到进阶

用户11456817

发布于 2025-08-28 08:47:43

8400

代码可运行

文章被收录于专栏：学习学习

运行总次数：0

代码可运行

模板初阶

泛型编程：

C++中一种使用模板来实现代码重用和类型安全的编程范式。它允许程序员编写与数据类型无关的代码，从而可以用相同的代码逻辑处理不同的数据类型。模板是泛型编程的基础

模板分为两类：

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

函数模板：

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

提供一个函数的模板，但是类型是不固定的，对于这种编程也叫泛型编程

Template<typename T1, typename T2,......,typename Tn>//模板格式


template<typename T>//T是一个类型的名称，没有要求；typename是一个关键字，后面跟的是泛型类型的名字，typename也能换成class。typename T合起来就是一个模板参数
void Swap(T& left,T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

template<typename T>
void Swap(T& left,T& right)
{
	T temp = left;
	left = right;
	right = temp;
}
int main()
{
	int x = 1, y = 2;
	double m = 1.1, n = 2.2;
	Swap(x,y);//这里两处函数调用，看似调用的是一个函数，但实际上时调用了两个函数（函数调用要建立栈帧，一个是int类型，一个double类型,类型大小都不一样，更不可能调用的是同一个函数了），这个可以从汇编层来观察
	Swap(m,n);
	return 0;
}

观察汇编代码发现，call的地址不一样，说明调用的不是同一个函数。

原理：

编译器通过你编写的模板，再根据你传入的参数，自行生成对应的函数，调用的就是这个编译器自行生成的函数

如果你传入两个参数，这两个参数的类型不一样，就需要写两个模板参数，否则编译会不通过

正确做法如下：

template<typename T1, typename T2>
void Swap(T1&left,T2&right)
{
	T1 temp = left;
	left = right;
	right = temp;
}
int main()
{
	int x = 1, y = 2;
	double m = 1.1, n = 2.2;
	Swap(x,n);
	Swap(m,y);
	return 0;
}

类模板

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

#include<iostream>
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;
};
// 模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误，具体原因后面会讲
template<class T>
void Stack<T>::Push(const T& data)
{
// 扩容
_array[_size] = data;
++_size;
}
int main()
{
Stack<int> st1;   // int
Stack<double> st2; // double
return 0;
}

实例化

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

// Stack是类名，Stack<int>才是类型
Stack<int> st1;   // int
Stack<double> st2; // double

模板进阶

非类型模板参数

模板参数不是只能传类型

template<class T,size_t N=20>//N也是模板参数，相比于宏，模板参数更加灵活
//在c++20标准下，模板参数还支持浮点数
//没有一个标准支持用容器来做模板参数，比如用string，没有为什么，就是标准不支持而已

模板的特化

对特殊的情况或者类型进行特殊化处理

分为函数模板特化、类模板特化

函数模板的特化步骤：

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

/*
  这里实现日期类
*/
template<class T>
bool Less(T left,T right)
{
  return left<right;
}
//函数模板特化
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,10,10);
  cout<<Less(d1,d2)<<endl;//这里调用的是特化模板
    
  return 0;
}

特化分为

全特化
偏特化：偏特化可以理解为对参数的一种限制，当是某种类型时，就走特定的模板

全特化

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

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

偏特化

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

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);  // 调用特化的指针版本
}

模板分离编译

什么是分离编译

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

模板的分离编译 假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义

// a.h
template<class T>
T Add(const T& left, const T& right);
// a.cpp
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
// main.cpp
#include"a.h"
int main()
{
Add(1, 2);
Add(1.0, 2.0);
return 0;
}