【C++】模板 - - - 泛型编程的魔法模具，一键生成各类代码

💻作者简介：曾与你一样迷茫，现以经验助你入门 C++。

💡个人主页：@笑口常开xpr 的个人主页

📚系列专栏：C++ 炼魂场：从青铜到王者的进阶之路✨代码趣语：模板是 "万能模具" - - - 不管是铁（int）、铜（double）还是塑料（自定义类），只要往模具里一放，就能按同样的造型（逻辑）做出对应材质的零件，不用每种材质都重新造个新模具。

💪代码千行，始于坚持，每日敲码，进阶编程之路。

📦gitee 链接：gitee

文章目录

[一、模版](#一、模版)
- [（1）作用](#（1）作用)
- （2）typename
- [（3）非类型模板参数](#（3）非类型模板参数)
- [（4）按需实例化](#（4）按需实例化)
- （5）array
[二、类模板](#二、类模板)
- [（1）定义](#（1）定义)
- [（2）作用](#（2）作用)
- [（3）基本语法](#（3）基本语法)
[三、特化](#三、特化)
- [（1）定义](#（1）定义)
- [（2）类模板](#（2）类模板)
- - [1、全特化](#1、全特化)
  - [2、偏特化](#2、偏特化)
- [（3）函数模板特化](#（3）函数模板特化)
[四、模板的分离编译](#四、模板的分离编译)
[五、优缺点](#五、优缺点)
- [（1）优点](#（1）优点)
- [（2）缺陷](#（2）缺陷)
[六、总结](#六、总结)

本文围绕 C++ 模板核心知识（类 / 函数模板、特化、分离编译等）及 vector、array 容器特性展开，结合代码示例拆解关键概念，助力入门者掌握泛型编程与容器使用基础。

一、模版

模版

（1）作用

模版可以控制容器的数据类型。
模版可以控制某种设计逻辑，比如适配器模式、数组栈、链表栈等等。
传递类型，使用仿函数，让类重载 operator()。

（2）typename

定义模版时可以使用 typename 或者 class，二者是等价的。

template<typename Container>
template<class Container>
使用类模板使用 :: 时要注意前面是类型还是对象。如果是类型，前面要加 typename，如果是对象，前面不需要。例如将函数改成泛型时，使用迭代器之前要加 typename。

javascript 复制代码

#include<vector>
#include<iostream>
using namespace std;

void Print(const vector<int>& v)
{
	vector<int>::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
}
//template<typename Container>//class和typename的作用一样
template<class Container>
void Print(const Container& v)
{
	typename Container::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
}
int main()
{
	vector<int> vec;
	vec.push_back(1);
	vec.push_back(2);
	vec.push_back(3);
	vec.push_back(4);
	for (auto e : vec)
	{
		cout << e << " ";
	}
	cout << endl;
	Print(vec);
	return 0;
}

Print 函数在没有使用模版之前，使用迭代器时进行了实例化，这里是类型，使用模版参数后没有实例化，无法区分迭代器前面是类型还是对象，使用 typename 来区分这里是类型还是对象。如果使用 auto 则不需要使用 typename。

（3）非类型模板参数

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

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

非类型形参：用一个常量作为类 (函数) 模板的一个参数，在类 ( 函数 ) 模板中可将该参数当成常量来使用。非类型模板参数必须是常量或者整型，主要用于定义数组。

javascript 复制代码

#include<iostream>
using namespace std;
template<class T,size_t N>
class stack
{
//静态栈
private:
	T _a[N];
	int _top;
};
int main()
{
	stack<int,10> st1;  //10
	stack<int,100> st2;  //100
	return 0;
}

上面的代码中 N 是非类型模板参数，N 是常量，不能修改 N，比 define 更灵活。作用域是整个类，形参的作用域是函数。T 是类型模板参数。

注意

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

（4）按需实例化

函数调用会进行实例化，如果不调用不会实例化。有的编译器会出现，Vs 编译器会出现这种情况。

javascript 复制代码

#include<iostream>
using namespace std;
template<class T,size_t N>
class stack
{
//静态栈
public:
	void Func()
	{
		N = 0;
	}
private:
	T _a[N];
	int _top;
};
int main()
{
	stack<int,10> st1;  //10
	stack<int,100> st2;  //100
	
	//按需实例化
	//st1.Func();
	return 0;
}

不调用 Func

代码编译成功。

调用 Func

代码编译失败。

（5）array

array

array 属于 C++ 中比较没用的东西，用处比较小，没有 vector 好用。也就是 C 语言中的数组。array 的优势在于处理数组越界的问题，数组越界时使用 array 会发生断言处理。C 语言的数组只能检查少部分的越界处理。

javascript 复制代码

#include<iostream>
#include<array>
using namespace std;
int main()
{
	array<int, 10> a;
	for (auto e : a)
	{
		cout << e << " ";
	}
	cout << endl;
	a[10];//越界访问会中断程序
	return 0;
}

二、类模板

类模板

（1）定义

类模板允许定义一个带参数的类，这个参数可以是任意类型，从而让类能适应多种数据类型，而不需要重复写多份代码。

（2）作用

实现类的泛型化，提高代码复用性。

（3）基本语法

javascript 复制代码

#include<iostream>
using namespace std;
template <class T>  // T是类型参数
class ClassName 
{
public:
    T member;
    ClassName(T m) : member(m) 
    {}
    void print() 
    {
        cout << member << endl;
    }
};
int main() 
{
    ClassName<int> obj1(10);      
    ClassName<double> obj2(3.14); 
    obj1.print(); 
    obj2.print(); 
    return 0;
}

使用类模板时，必须显式指定类型参数（编译器不会像函数模板那样自动推导类模板类型）。

三、特化

（1）定义

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理。在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。

（2）类模板

1、全特化

全特化即是将模板参数列表中所有的参数都确定化。（必须包括原来的类型）

javascript 复制代码

#include<iostream>
using namespace std;
template <class T>
class Pair 
{
public:
    Pair(T a, T b) 
        : first(a)
        , second(b) 
    {}
    void print() 
    {
        cout << first << " " << second << endl;
    }
private:
    T first, second;
};

//全特化版本
template<>
class Pair<int> 
{
public:
    Pair(int a, int b) 
        : first(a)
        , second(b) 
    {}
    void print() 
    {
        cout << "int special: " << first << ", " << second << endl;
    }
private:
    int first, second;
};
int main()
{
    Pair<double> p1(1.2, 3.4); //调用普通模板
    Pair<int> p2(10, 20);      //调用全特化版本
    p1.print();
    p2.print();
	return 0;
}

2、偏特化

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

javascript 复制代码

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

两种表现方式：

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

javascript 复制代码

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

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

javascript 复制代码

//两个参数偏特化为指针类型
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;
};
int main()
{
	Data<double, int> d1;	   //调用特化的int版本
	Data<int, double> d2;	   //调用基础的模板
	Data<int*, int*> d3;	   //调用特化的指针版本
	Data<int&, int&> d4(1, 2); //调用特化的指针版本
	return 0;
}

（3）函数模板特化

步骤

必须要先有一个基础的函数模板
关键字 template 后面接一对空的尖括号 <>
函数名后跟一对尖括号，尖括号中指定需要特化的类型
函数形参表：必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
函数模板可以全特化（不能偏特化）。
如果需要针对某类类型做特殊处理，通常用函数重载代替特化。

javascript 复制代码

#include<iostream>
using namespace std;
//函数模板 --- 参数匹配
template <class T>
bool Less(T a, T b) 
{
	cout << "Less(T a, T b)" << " ";
	return a < b;
}
//全特化版本(针对int*)
template <>
bool Less<int*>(int* a, int* b) 
{
	cout << "Less<int*>" << " ";
	return *a < *b;
}
int main()
{
	int a = 1;
	int b = 2;
	cout << Less(a, b) << endl;
	cout << Less(&a, &b) << endl;
	return 0;
}

四、模板的分离编译

定义

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

stack.cpp

javascript 复制代码

#include"stack.h"
using namespace sta;

template<class T, class Container>
void stack<T,Container>::push(const T& x)
{
	_con.push_back(x);
}

template<class T, class Container>
void stack<T, Container>::pop()
{
	_con.pop_back();
}

void A::func1()
{

}
//void A::func2()

stack.h

javascript 复制代码

#pragma once
#include<vector>
#include<list>
#include<iostream>
using namespace std;
namespace sta
{
	template<class T,class Container = vector<T>>
	class stack
	{
	public:
		void push(const T& x);
		void pop();
		T& top()
		{
			return _con.back();
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
	class A
	{
	public:
		void func1();
		void func2();
	};
}

test.cpp

javascript 复制代码

#include"stack.h"
using namespace sta;
int main()
{
	stack<int> st;
	//有声明和定义
	st.push(1);
	st.push(2);
	st.push(3);
	A aa;
	aa.func1();//有声明和定义
	aa.func2();//有声明没有定义
	return 0;
}

这里是链接错误，找不到地址。编译阶段看只有声明，声明是一种承诺，所以编译阶段检查声明函数名参数返回可以对上。等着链接的时候，使用修饰后的函数去查找。

3 种情况

func1 有声明和定义，链接成功。
func2 有声明没有定义，链接失败。
push 有声明和定义，链接失败。

方法 1

可以在所有定义最后面添加下面的代码即可，这种方式被称做显示实例化，func2 需要添加定义。

复制代码

template
class stack<int>;

方法 2

将声明和定义放到一个文件 "xxx.hpp" 里面或者 "xxx.h" 其实也是可以的。这里推荐使用这种方式。

五、优缺点

（1）优点

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

（2）缺陷

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

六、总结

本文梳理了 C++ 模板的复用逻辑、特化规则及分离编译问题，也明确了 vector 与 array 的特性差异；模板虽提升代码灵活性，但需注意编译膨胀与错误定位问题，掌握这些内容是高效编写 C++ 代码的重要基础。

【C++】模板 - - - 泛型编程的魔法模具，一键生成各类代码

文 章 目 录

一、模 版

（1）作 用

（2）typename

（3）非 类 型 模 板 参 数

（4）按 需 实 例 化

（5）array

二、类 模 板

（1）定 义

（2）作 用

（3）基 本 语 法

三、特 化

（1）定 义

（2）类 模 板

1、全 特 化

2、偏 特 化

（3）函 数 模 板 特 化

四、模 板 的 分 离 编 译

五、优 缺 点

（1）优 点

（2）缺 陷

六、总 结

文章目录

一、模版

（1）作用

（3）非类型模板参数

（4）按需实例化

二、类模板

（1）定义

（2）作用

（3）基本语法

三、特化

（1）定义

（2）类模板

1、全特化

2、偏特化

（3）函数模板特化

四、模板的分离编译

五、优缺点

（1）优点

（2）缺陷

六、总结