C++ 模板再升级：非类型参数、特化技巧（含全特化与偏特化）、分离编译破解

孤廖2025-10-21 10:01



✨ 孤廖： 个人主页

🎯 个人专栏： 《C++：从代码到机器》

🎯 个人专栏： 《Linux系统探幽：从入门到内核》

🎯 个人专栏： 《算法磨剑：用C++思考的艺术》

折而不挠，中不为下

文章目录

  • 前言
  • 正文
    • [1. 非类型模板参数](#1. 非类型模板参数)
    • [2. 模板的特化](#2. 模板的特化)
      • [2.1 概念](#2.1 概念)
      • [2.2 函数模板特化](#2.2 函数模板特化)
      • [2.3 类模板特化](#2.3 类模板特化)
        • [2.3.1 全特化](#2.3.1 全特化)
        • [2.3.2 偏特化](#2.3.2 偏特化)
        • [2.3.3 类模板特化应用示例](#2.3.3 类模板特化应用示例)
    • [3 模板分离编译](#3 模板分离编译)
      • [3.1 什么是分离编译](#3.1 什么是分离编译)
      • [3.2 模板的分离编译](#3.2 模板的分离编译)
      • [3.3 解决方法](#3.3 解决方法)
    • [4. 模板总结](#4. 模板总结)
  • 结语:

前言

上篇《还在为泛型编程头疼？函数模板与类模板核心要点速通》

我们介绍了 C++中的模板初阶 这篇博客继续聚焦模板 展开进阶的学习

正文

1. 非类型模板参数

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

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

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

非类型 形参 相较宏定义 修改时 不用找 宏定义语句 修改 代码 而是类实例化对象时传入非类型形参的常量值即可

cpp 复制代码 
#pragma once


namespace twg
{
	template<class T ,size_t N>
	class Vector
	{
		
	public:

		T& operator[](size_t _index)
		{
			return _array[_index];
		}
		bool empty() const
		{
			return _size == 0;
		}
		size_t size() const
		{
			return _size;
		}
		// ....

	private:
		T* _array[N];
		size_t size;
	};
	//通过传不同的值 实例化对象时 自动推导 类型T  和非类型参数常量值N
	Vector<int, 10> a;
	Vector<char ,9> b;
}

注意

  1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的
  2. 非类型的模板参数必须在编译期就能确认结果。

总之非类型模板参数 必须是整形家族的 比如 char short int long bool...

2. 模板的特化

2.1 概念

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

cpp 复制代码 
class Date
	{
	public:
		Date(int year = 1900, int month = 1, int day = 1)
			: _year(year)
			, _month(month)
			, _day(day)
		{}
		bool operator<(const Date& d)const
		{
			return (_year < d._year) ||
				(_year == d._year && _month < d._month) ||
				(_year == d._year && _month == d._month && _day < d._day);
		}
		bool operator>(const Date& d)const
		{
			return (_year > d._year) ||
				(_year == d._year && _month > d._month) ||
				(_year == d._year && _month == d._month && _day > d._day);
		}
		friend ostream& operator<<(ostream& _cout, const Date& d)
		{
			_cout << d._year << "-" << d._month << "-" << d._day;
			return _cout;
		}
	private:
		int _year;
		int _month;
		int _day;
	};
	//模板函数

	template<class T>
	bool Less(T a, T b)
	{
		return a < b;
	}
	int a = 10;
	int b = 20;
	cout << Less(a, b) << endl;//可以比较 结果正确

	Date c(2025, 10, 20);
	Date d(2025, 10, 25);
	Date* Pc = &c;
	Date* Pd = &d;
	cout << Less(c, d) << endl;//可以比较 ，结果正确
	cout << Less(Pc, Pd) << endl;//可以比较 ，结果错误

可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，Pc指向的c显然小于Pd指向的d对象，但是Less内部并没有比较Pc和Pd指向的对象内

容，而比较的是Pc和Pd指针的地址，这就无法达到预期而错误
此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化

2.2 函数模板特化

函数模板的特化步骤：

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

【代码解释：】

cpp 复制代码 
class Date
	{
	public:
		Date(int year = 1900, int month = 1, int day = 1)
			: _year(year)
			, _month(month)
			, _day(day)
		{}
		bool operator<(const Date& d)const
		{
			return (_year < d._year) ||
				(_year == d._year && _month < d._month) ||
				(_year == d._year && _month == d._month && _day < d._day);
		}
		bool operator>(const Date& d)const
		{
			return (_year > d._year) ||
				(_year == d._year && _month > d._month) ||
				(_year == d._year && _month == d._month && _day > d._day);
		}
		friend ostream& operator<<(ostream& _cout, const Date& d)
		{
			_cout << d._year << "-" << d._month << "-" << d._day;
			return _cout;
		}
	private:
		int _year;
		int _month;
		int _day;
	};
	

	//模板函数

	template<class T>
	bool Less(T a, T b)
	{
		return a < b;
	}
	//模板特化  Date*
	template<>
	bool Less<Date*>(Date* a, Date* b)
	{
		return *a < *b;
	}

	int a = 10;
	int b = 20;
	cout << Less(a, b) << endl;//可以比较 结果正确

	Date c(2025, 10, 20);
	Date d(2025, 10, 25);
	Date* Pc = &c;
	Date* Pd = &d;
	cout << Less(c, d) << endl;//可以比较 ，结果正确
	cout << Less(Pc, Pd) << endl;//// 调用特化之后的版本，而不走模板生成了

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

故模板特化的应用场景还是挺少的 因为能直接重写一个特殊的函数 为什么还要用特化模板函数呢 而且 特化模板的函数参数 还容易与原模板函数传参对比上产生歧义

cpp 复制代码 
bool Less(Date* left, Date* right)
{
return *left < *right;
}

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

2.3 类模板特化

2.3.1 全特化

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

cpp 复制代码 
template<class T1,class T2>
	class date
	{
	public:date(){ cout << "data<T1, T2>" << endl; }
	private:
		T1 a;
		T2 b;
	};
	//类模板全特化

	template<>
	class date<int,char>
	{
	public:date() { cout << "data<int, char>" << endl; }
	private:
		int a;
		char b;
	};


	void test3()
	{
		date<int, int > a;
		date <int, char> b;
	}
2.3.2 偏特化

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

cpp 复制代码 
template<class T1,class T2>
	class date
	{
	public:date(){ cout << "data<T1, T2>" << endl; }
	private:
		T1 a;
		T2 b;
	};
	//类模板全特化

	template<>
	class date<int,char>
	{
	public:date() { cout << "data<int, char>" << endl; }
	private:
		int a;
		char b;
	};

	//对类模板的偏特化
	//将第二个参数特化成int
	template<class T1>
	class date<T1, int >
	{
	public:date() { cout << "data<T1, int>" << endl; }
	private:
		T1 a;
		int b;
	};

	//两个模板参数特化成指针类类型
	template<class T1,class T2>
	class date<T1*, T2*>
	{
	public:date() { cout << "data<T1*, T2*>" << endl; }
	private:
		T1* a;
		T2* b;
	};


	//两个模板参数特化成引用类型
	template<class T1, class T2>
	class date<T1&, T2&>
	{
	public:date(const T1& d1, const T2& d2)
			: _d1(d1)
			, _d2(d2)
		{
			cout << "data<T1&, T2&>" << endl;
		}
	
	private:
		const T1& a;
		const T2& b;
	};



	void test3()
	{
		date<int, int > a;
		date <int, char> b;
	}

	void test4()
	{
		date<double, int> d1; // 调用特化的int版本
		date<int, double> d2; // 调用基础的模板
		date<int*, int*> d3; // 调用特化的指针版本
		date<int&, int&> d4(1,2); // 调用特化的指针版本
	}
2.3.3 类模板特化应用示例

参考应用示例 更好的理解应用
有如下专门用来按照小于比较的类模板Less：

cpp 复制代码 
#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模板中方式比较，所以只会比较指

针，而不是比较指针指向空间中内容，此时可以使用类版本特化来处理上述问题

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

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

3 模板分离编译

在模板初阶中 我说过 模板类中函数的声明和定义不要放在两个文件里

这样会导致 文件链接成为可执行程序 时 链接失败 找不到特定类
接下来 我会系统性的从源文件生成可执行文件的过程来阐述为什么类模板分离 会导致文件间的链接错误

3.1 什么是分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有

目标文件链接起来形成单一的可执行文件的过程称为分离编译模式

以.c文件为案列 形成可执行文件的过程中 有四个过程：

  1. 预处理 -> 处理头文件的包含 ,宏的替换 ,注释的删除,等等 该步骤完成后.h 文件就不参与下面的过程
  2. 编译 ->所有的.c文件依次编译生成.i -> .s -> .o 文件 转换为汇编语言
  3. 汇编 -> 将汇编语言 转换为 计算机能识别的二进制语言
  4. 链接 -> 将所有的已经经过上述步骤的文件 通过符号表中的函数指针 链接在一块 (包括库中的函数)

3.2 模板的分离编译

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

cpp 复制代码 
// 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;
}

分析:

无论是类模板函数还是模板类 只有在实例化对象时 才会生成相应的函数或者类

也就是说 两个分离的文件分别形成的obj文件 内部没有具体的实例化函数 或者类 即 没有Add(int ,int) 和Add(double ,double)两个类函数 说白了 这两个文件里经过编译器优化后甚至没有Add这个痕迹

3.3 解决方法

  1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。
  2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用

分离编译扩展阅读

4. 模板总结

【优点】

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

【缺陷】

  1. 模板会导致代码膨胀问题，也会导致编译时间变长
  2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误

结语:

看到这里，你已经把 C++ 模板进阶的核心知识点啃下来了 ------ 从能用常量当参数的 "非类型模板参数"，到解决特殊类型适配的 "模板特化"（尤其是类模板的全特化与偏特化），再到避开 "分离编译链接错误" 的实战技巧，这些都是从 "会用模板" 到 "用好模板" 的关键跨越

其实模板的价值远不止于此，比如后续 STL 源码里大量依赖模板特化做适配，泛型编程也靠模板支撑。要是现在对 "偏特化的条件限制""显式实例化的用法" 还有模糊，不妨回头跑一遍示例代码；想进一步深入，也可以试着用模板特化优化自己之前写的容器类。

如果觉得本篇文章对您C++的模板理解有所帮助 请给作者三连吧 感激不尽!

相关推荐
liu****3 小时前
19.map和set的封装
开发语言·数据结构·c++·算法
润 下3 小时前
C语言——回调函数的典型示例（分析详解）
c语言·开发语言·人工智能·经验分享·笔记·程序人生
朝新_3 小时前
【EE初阶 - 网络原理】传输层协议
java·开发语言·网络·笔记·javaee
林希_Rachel_傻希希3 小时前
Express 入门全指南：从 0 搭建你的第一个 Node Web 服务器
前端·后端·node.js
oak隔壁找我3 小时前
Java 使用技巧与最佳实践
java·后端
oak隔壁找我3 小时前
SpringMVC 使用技巧与最佳实践
java·后端
oak隔壁找我3 小时前
Spring 框架使用技巧与最佳实践
java·后端
白衣鸽子3 小时前
MySql数据库同步技术：构建高可用架构的基石
数据库·后端
xyy1233 小时前
Visual Studio 添加测试项目
后端
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03UV安装并设置国内源04Linux下V2Ray安装配置指南05GitLab 零基础入门指南：从安装到项目管理全流程06XXE 注入漏洞全解析：从原理到实战07NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南08在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）092025软件测试面试八股文（含答案+文档）10两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答