C++ 模板进阶 - 技术栈

C++ 模板作为泛型编程的核心基石，是实现代码复用、类型安全与高性能的关键技术。从标准库中的容器、算法到日常开发中的通用组件，模板无处不在。本文将从非类型模板参数、模板特化（全特化/偏特化）、模板分离编译三大核心知识点展开，结合源码与实例深度解析，带你系统掌握C++模板的底层原理与使用细节。

1. 非类型模板参数

1.1 概念

模板参数分为两类：

• 类型形参：出现在模板参数列表中，跟在 class 或 typename 之后，代表一个类型。

• 非类型形参：用一个常量作为类（或函数）模板的参数，在类（或函数）模板中可将该参数当成常量来使用。

1.2 示例：静态数组模板

cpp 复制代码

namespace gxy
{
    // 定义一个模板类型的静态数组
    template<class T, size_t N = 10>
    class array
    {
    public:
        // 重载[]运算符，支持读写
        T& operator[](size_t index) { return _array[index]; }
        // 重载const版本的[]运算符，支持只读
        const T& operator[](size_t index) const { return _array[index]; }

        // 获取数组大小
        size_t size() const { return _size; }
        // 判断数组是否为空
        bool empty() const { return 0 == _size; }

    private:
        T _array[N];      // 数组大小由非类型模板参数N决定
        size_t _size;      // 数组中有效元素个数
    };
}

cpp 复制代码

template<size_t N = 10, bool flag = false>
class Stack
{
private:
    int _a[N];  // 数组大小由非类型模板参数N决定
    int _top;   // 栈顶指针
};

// 非类型模板参数可以有默认值，实例化时可以只提供部分参数，未提供的参数将使用默认值。
int main()
{
    Stack<> s0;        // 使用默认参数：N=10, flag=false
    Stack<5> s1;       // N=5, flag=false（第二个参数使用默认值）
    Stack<10, true> s2;// N=10, flag=true

    return 0;
}

// C++20
//template<double D>
//class A
//{
//private:
//
//};
// 这段代码被注释掉，因为在 C++11/14/17 标准中，浮点数（如 double）不允许作为非类型模板参数。
// 这一限制在 C++20 标准中被放宽，浮点数可以作为非类型模板参数，因此这段代码在 C++20 及以后的编译器中是合法的。

• template<size_t N = 10, bool flag = false>：定义了两个非类型模板参数：

N：类型为 size_t，默认值为 10，用于指定栈的容量。 flag：类型为 bool，默认值为 false，可用于控制栈的行为（如是否启用调试模式等）。

• int _a[N];：这是一个编译期大小的静态数组。N 是编译期常量，因此数组大小在编译时就已确定，这与 std::array 的原理一致。

非类型模板参数的核心规则

类型限制：

允许：整型（int, size_t 等）、指针、左值引用、std::nullptr_t。

不允许（C++17及之前）：浮点数、类对象、字符串。

C++20 起：允许浮点数和字面量类型（LiteralType）的类对象。

编译期常量：

非类型模板参数的值必须在编译期就能确定，因为它们是用来生成代码的常量。

默认值：

非类型模板参数也可以像函数参数一样，指定默认值。

1.3 C++ 静态数组与动态容器的深度对比（array vs vector vs 原生数组）

cpp 复制代码

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

// 非类型模板参数示例：静态数组 array
template<class T, size_t N = 10>
class array
{
public:
	T& operator[](size_t index)
	{
		assert(index < N);
		return _array[index];
	}

	const T& operator[](size_t index) const
	{
		assert(index < N);
		return _array[index];
	}

	size_t size() const
	{
		return N;
	}

private:
	T _array[N];
};

// 非类型模板参数：栈
template<size_t N = 10, bool flag = false>
class Stack
{
private:
	int _a[N];
	int _top;
};

// C++20 才支持 double 作为非类型模板参数
// template<double D>
// class A
// {
// private:
//
// };

int main()
{
	// 静态 array（栈上）
	array<int, 10> a1;
	array<int, 100> a2;

	// 原生数组
	int a3[10];

	// 原生数组越界：不检查 / 抽查
	cout << a3[10] << endl;
	a3[12] = 10;
	a3[20] = 10;

	// array 越界：assert 直接报错
	// a1[10];
	// a1[12] = 10;

	// vector（动态数组，堆上）
	vector<int> v(100, 1);

	// 大小对比：array 是真大小，vector 是对象大小
	cout << "sizeof(a2) = " << sizeof(a2) << endl;
	cout << "sizeof(v) = " << sizeof(v) << endl;

	// Stack 非类型模板参数测试
	Stack<> s0;
	Stack<5> s1;
	Stack<10> s2;

	return 0;
}

核心知识点解析

越界检查机制的巨大差异

|---------------------|-------------|------------|-------------------------|
| 数据结构 | 越界读行为 | 越界写行为 | 检察机制 |
| 原生数组 (int a3[10]) | 不检查，可能读到随机值 | 抽查，触发崩溃概率低 | 仅依赖操作系统的内存保护，编译器不负责 |
| 自定义 array | 直接崩溃 | 直接崩溃 | assert 断言，强制运行时检查 |
| std::vector | 未定义行为 | 未定义行为 | at() 方法会抛异常，[] 运算符不检查 |

代码分析：

cpp 复制代码

// 原生数组：越界读通常不会崩溃，返回垃圾值
cout << a3[10] << endl; 

// 原生数组：越界写可能覆盖其他内存，导致程序诡异崩溃或安全问题
// a3[20] = 10; 

// 自定义array：越界会触发 assert 失败，程序直接终止并报错
// a1[10] = 10; // 断言失败：index < N

结论：原生数组的越界是 C++ 程序的"隐形杀手"。使用 assert 封装的 array 模板，能在调试阶段强制暴露越界问题。

内存布局与大小计算 (sizeof)

代码中通过 sizeof 揭示了静态与动态的本质区别：

cpp 复制代码

array<int, 100> a2;
vector<int> v(100, 1);

cout << sizeof(a2) << endl;  // 输出：400 (100 * 4字节)
cout << sizeof(v) << endl;   // 输出：24 (或 32，取决于编译器)

深度解析：

array (静态容器)： sizeof(a2) 直接等于元素总大小。它是一个聚合类型，底层就是一个裸数组 T _array[N]，存储在栈（Stack）上。没有额外的空间开销（无指针、无容量变量）。
vector (动态容器)： sizeof(v) 是容器对象本身的大小，与存储的元素数量无关。它通常包含 3 个指针（开始、结束、容量尾），在 64 位系统下就是 8 * 3 = 24 字节。实际数据存储在堆（Heap）上，vector 对象只保存指向堆内存的指针。

技术选型建议

通过以上对比，在实际开发中应遵循以下原则：

确定大小的小数组：使用 std::array（即你实现的这种模板）。

优点：栈上分配，速度快，无内存泄漏风险，支持越界检查。

大小不确定或动态变化：使用 std::vector。

优点：堆上分配，支持动态扩容，功能丰富。

绝对避免：原生 C 风格数组（int a[10]）。

缺点：容易越界，退化为指针，丢失大小信息。

拓展：

cpp 复制代码

#include <iostream>
using namespace std;

void func()
{
    // 这个 a 是 func 函数内部的**局部变量**
    // 存在栈帧（栈空间）里
    int a = 1;
    cout << &a << endl;  // 打印它的地址
}

int main()
{
    // 这个 a 是 main 函数内部的**局部变量**
    // 和上面 func 里的 a 是**两个完全不同的变量**
    int a = 0;
    cout << &a << endl;  // 打印它的地址

    func(); // 调用函数，会创建新的栈帧

    return 0;
}

核心知识点

两个 a 完全没关系：作用域不同，地址不同，生命周期不同
局部变量都存在栈上：每调用一个函数，就会开辟一个栈帧，函数结束，栈帧销毁，局部变量失效
运行结果一定是：两个不同的地址

总结：不同函数里的局部变量，名字可以一样，但完全是两个东西，地址也不一样。

1.4 注意事项

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

2. 模板的特化

2.1 概念

通常情况下，使用模板可以实现与类型无关的代码，但对于一些特殊类型，可能会得到错误的结果，需要特殊处理。

示例：通用的小于比较函数模板

cpp 复制代码

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
    return left < right;
}

int main()
{
    cout << Less(1, 2) << endl; // 可以比较，结果正确（1<2为真）

    Date d1(2022, 7, 7);
    Date d2(2022, 7, 8);
    cout << Less(d1, d2) << endl; // 可以比较，结果正确（d1 < d2为真）

    Date* p1 = &d1;
    Date* p2 = &d2;
    cout << Less(p1, p2) << endl; // 可以比较，但结果错误！
    // 这里比较的是指针p1和p2的地址值，而非它们指向的Date对象内容
    return 0;
}

可以看到，Less 在比较指针时行为不符合预期，此时就需要对模板进行特化，即在原模板的基础上，针对特殊类型进行特殊实现。

2.2 函数模板特化

2.2.1 特化步骤

必须要先有一个基础的函数模板。
关键字 template 后面接一对空的尖括号 <>.
函数名后跟一对尖括号，尖括号中指定需要特化的类型。
函数形参表：必须要和模板函数的基础参数类型完全相同，否则可能报奇怪的错误。

2.2.2 示例：特化指针版本的Less

cpp 复制代码

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
    return left < right;
}

// 对Less函数模板进行特化，处理Date*类型
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;
}

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

cpp 复制代码

#include <iostream>
using namespace std;

// 先定义 Date 类（必须有，否则代码跑不起来）
class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	// 必须重载 < 才能比较
	bool operator<(const Date& d) const
	{
		if (_year != d._year)
			return _year < d._year;
		if (_month != d._month)
			return _month < d._month;
		return _day < d._day;
	}

	// 方便打印
	friend ostream& operator<<(ostream& out, const Date& d)
	{
		out << d._year << "-" << d._month << "-" << d._day;
		return out;
	}

private:
	int _year;
	int _month;
	int _day;
};

// 函数模板 -- 通用版本
// 通用比较，适合 int、double、Date 对象；但不适合 指针，因为直接比地址
template<class T>
bool LessFunc(const T& left, const T& right)
{
	return left < right;
}

// 方法1：函数模板特化（写法复杂，不推荐）
// template<>
// bool LessFunc<Date*>(Date* const& left, Date* const& right)
// {
//     return *left < *right;
// }
//
// template<>
// bool LessFunc<const Date*>(const Date* const& left, const Date* const& right)
// {
//     return *left < *right;
// }

// 方法2：直接写普通函数（简单、直观、最推荐！）
bool LessFunc(const Date* left, const Date* right)
{
	return *left < *right;
}

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

int main()
{
	// 1. 普通 int 比较
	cout << LessFunc(1, 2) << endl;

	// 2. Date 对象比较
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 8);
	cout << LessFunc(d1, d2) << endl;

	// 3. Date* 指针比较（走普通函数，解引用比较，结果正确）
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << LessFunc(p1, p2) << endl;

	// 4. const Date* 比较（也走普通函数，结果正确）
	const Date* p3 = &d1;
	const Date* p4 = &d2;
	cout << LessFunc(p3, p4) << endl;

	return 0;
}

函数匹配规则：普通函数优先于模板函数；所以指针会自动走我们写的普通函数；简单、好用、不出错

函数模板特化（不推荐）：语法复杂，容易写错，不如直接写普通函数

2.3 类模板特化

2.3.1 全特化

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

cpp 复制代码

#include <iostream>
using namespace std;

// 原始类模板
template<class T1, class T2>
class Data
{
public:
	Data() 
	{ 
		cout << "Data<T1, T2>" << endl; 
	}

private:
	T1 _d1;
	T2 _d2;
};

// 全特化：把 T1=int, T2=char 这一组类型单独特殊处理
// 全特化 = 把所有模板参数都写死
template<>
class Data<int, char>
{
public:
	Data() 
	{ 
		cout << "Data<int, char>" << endl; 
	}
};

// 测试
int main()
{
	Data<double, double> d1;   // 走通用模板
	Data<int, int> d2;         // 走通用模板
	Data<int, char> d3;        // 走【全特化】版本

//匹配规则：特化版本优先；只要是 Data<int, char> → 走特化；其他 → 走原来的模板
	return 0;
}

2.3.2 偏特化

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

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

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

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

示例1：部分特化

cpp 复制代码

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

示例2：参数更进一步的限制

cpp 复制代码

#include <iostream>
using namespace std;

// 基础类模板，只要不是指针、不是引用组合，都走它。
template <typename T1, typename T2>
class Data
{
public:
    Data()
    {
        cout << "Data<T1, T2>" << endl;
    }

private:
    T1 _d1;
    T2 _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;      // 调用基础模板
    Data<int, double> d2;      // 调用基础模板
    Data<int*, int*> d3;       // 调用指针偏特化
    Data<int&, int&> d4(1, 2); // 调用引用偏特化
}

int main()
{
    test2();
    return 0;
}

输出结果：

cpp 复制代码

Data<T1, T2>
Data<T1, T2>
Data<T1*, T2*>
Data<T1&, T2&>

示例3:

cpp 复制代码

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

// 原始通用类模板
template <typename T1, typename T2>
class Data
{
public:
    Data()
    {
        cout << "Data<T1, T2>" << endl;
    }
private:
    T1 _d1;
    T2 _d2;
};

// ================================
// 偏特化（部分特化）
// 限制 T1 必须是 引用类型 &
// 限制 T2 必须是 指针类型 *
// ================================
template <typename T1, typename T2>
class Data <T1&, T2*>
{
public:
    Data()
    {
        cout << "Data<T1&, T2*>" << endl;

        int a = 0;

        // T1& 是 int&（引用折叠后）
        T1& x = a;

        // T2* 是 int*
        T2* y = &a;

        // T1 是 int
        T1 z = a;

        // 打印类型
        cout << "x 类型：" << typeid(x).name() << endl;
        cout << "y 类型：" << typeid(y).name() << endl;
    }

    void Push(const T1& x)
    {}
};

// 测试
int main()
{
    // 匹配偏特化：Data<T1&, T2*>
    Data<int&, int*> d;

    return 0;
}

输出结果：

cpp 复制代码

Data<T1&, T2*>
x 类型：int
y 类型：int *

Data<T1&, T2*>进入了这个偏特化版本。
typeid(x).name()： x 是 int& 类型，但 typeid 会忽略引用，所以输出：int
typeid(y).name()： y 是 int* 类型，原样输出：int *
偏特化的本质：不是把类型写死，而是对类型加限制：必须是引用，必须是指针，必须是某种组合，这就是偏特化（partial specialization）。

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

    // 直接排序结果错误，因为sort比较的是指针地址
    // 此处需要特化处理指针
    sort(v2.begin(), v2.end(), Less<Date*>());
    return 0;
}

对Less类模板按照指针方式特化：

cpp 复制代码

template<>
struct Less<Date*>
{
    bool operator()(Date* x, Date* y) const
    {
        return *x < *y; // 解引用，比较指针指向的对象
    }
};

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

2.3.4 实现 PriorityQueue.h

cpp 复制代码

#pragma once

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

// 仿函数：小于比较（默认大堆）
template<class T>
class Less
{
public:
	bool operator()(const T& x, const T& y) const
	{
		return x < y;
	}
};

// 偏特化：对所有指针类型进行特化
// 比较指针指向的内容，而不是地址
template<class T>
class Less<T*>
{
public:
	bool operator()(T* const& x, T* const& y) const
	{
		return *x < *y;
	}
};

// 仿函数：大于比较（用来构造小堆）
template<class T>
class Greater
{
public:
	bool operator()(const T& x, const T& y) const
	{
		return x > y;
	}
};

namespace gxy
{
	// 优先级队列（默认：Less 仿函数 → 大堆）
	template<class T, class Container = vector<T>, class Compare = Less<T>>
	class priority_queue
	{
	public:
		// 向上调整（建堆、push 用）
		void AdjustUp(int child)
		{
			Compare com;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				// 通过仿函数比较：com(父, 子)
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void push(const T& x)
		{
			_con.push_back(x);
			AdjustUp(_con.size() - 1);
		}

		// 向下调整（pop 用）
		void AdjustDown(int parent)
		{
			Compare com;
			size_t child = parent * 2 + 1;

			while (child < _con.size())
			{
				// 找出较大/较小的孩子（由仿函数决定）
				if (child + 1 < _con.size()
					&& com(_con[child], _con[child + 1]))
				{
					++child;
				}

				// 交换父子
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		void pop()
		{
			swap(_con[0], _con.back());
			_con.pop_back();
			AdjustDown(0);
		}

		const T& top() const
		{
			return _con[0];
		}

		size_t size() const
		{
			return _con.size();
		}

		bool empty() const
		{
			return _con.empty();
		}

	private:
		Container _con;
	};
}

test.cpp

cpp 复制代码

#include <iostream>
#include "PriorityQueue.h"
using namespace std;

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	bool operator<(const Date& d) const
	{
		if (_year != d._year)
			return _year < d._year;
		if (_month != d._month)
			return _month < d._month;
		return _day < d._day;
	}

	friend ostream& operator<<(ostream& out, const Date& d)
	{
		out << d._year << "-" << d._month << "-" << d._day;
		return out;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	// 测试 Date 对象
    // 定义一个优先队列（堆），名字叫 q1，里面存的是Date类型的对象（不是指针，是日期对象）
    // 默认使用：底层容器：vector<Date>，比较仿函数：Less<Date>→ 默认是大顶堆（最大值优先）
	gxy::priority_queue<Date> q1;
	q1.push(Date(2018, 10, 29)); // 每次push，都会自动向上调整（AdjustUp），维持大顶堆
	q1.push(Date(2018, 10, 28));
	q1.push(Date(2018, 10, 30));

	cout << q1.top() << endl;   // 输出 2018-10-30
    q1.pop();                  // 删掉堆顶

    cout << q1.top() << endl;   // 输出 2018-10-29
    q1.pop();

    cout << q1.top() << endl;   // 输出 2018-10-28

	// 测试 Date*
	gxy::priority_queue<Date*> q2; // 默认使用：vector<Date*>，比较仿函数：Less<Date*>
    // 定义一个优先队列（堆），名字叫 q2里面存的是 Date* 类型的指针
	q2.push(new Date(2018, 10, 29));
	q2.push(new Date(2018, 10, 28));
	q2.push(new Date(2018, 10, 30));
    //new Date(...) 在堆上创建一个日期对象；返回这个对象的地址（指针）；把指针 push 进优先队列
    //每次 push 都会调用 AdjustUp 维持大顶堆

	cout << *q2.top() << endl; 
	q2.pop();
	cout << *q2.top() << endl;
	q2.pop();
	cout << *q2.top() << endl;
	q2.pop();
	cout << endl;
    // q2.top() 得到的是堆顶的 Date 指针*，必须用*解引用，才能输出日期对象
    // 每次pop()删掉堆顶，重新向下调整恢复堆

	// 测试 int*
	gxy::priority_queue<int*> q3; 
    // 定义一个优先队列（堆），名字叫 q3，里面存放的是 int 类型的指针*
	q3.push(new int(2));
	q3.push(new int(1));
	q3.push(new int(3));

	cout << *q3.top() << endl;
	q3.pop();
	cout << *q3.top() << endl;
	q3.pop();
	cout << *q3.top() << endl;
	q3.pop();

	return 0;
}

输出结果：

cpp 复制代码

priority_queue 不是在某一个函数里"一次性排序"，而是靠「向上调整 + 向下调整」全程维持堆结构，始终保证堆顶是最大/最小。

最核心答案：在哪里排序？排序 = 维持堆结构，发生在 2 个地方：

1） push 数据时 → AdjustUp 向上调整 2） pop 数据时 → AdjustDown 向下调整

没有单独的 sort 函数！堆结构本身就是自排序的。

逐行告诉你：哪里在排序

① push 时排序（向上调整）
void push(const T& x)
{
_con.push_back(x); // 放最后
AdjustUp(_con.size() - 1); // 👈 这里排序！
}

AdjustUp 做的事：从最后一个节点往上，和父亲比较，不符合堆规则就交换，直到维持好大/小堆

② pop 时排序（向下调整）
void pop()
{
swap(_con[0], _con.back()); // 堆顶和最后一个交换
_con.pop_back(); // 删除原来的堆顶
AdjustDown(0); // 👈 这里重新排序！
}

AdjustDown 做的事：从堆顶往下，和孩子比较，找出最大/最小孩子交换，重新恢复堆规则

真正的"比较大小、决定排序规则"在哪里？在 AdjustUp / AdjustDown 里面的仿函数：
Compare com;

// 这里决定谁大谁小
if (com(_con[parent], _con[child]))
{
swap(...);
}

• Less → 大堆； Greater → 小堆；Less<T*> → 指针比较内容，不是地址这就是排序的逻辑核心。

超级精简总结（背会）：push → AdjustUp 向上排序，pop → AdjustDown 向下排序，比较规则由仿函数控制，整个容器永远是一个堆，也就是时刻有序。

总结：

仿函数 functor：Less / Greater 用于控制堆的比较规则。
类模板偏特化：Less<T*> 对所有指针类型特化，比较指针指向内容，不是地址。
优先级队列 = 堆 + 容器适配器：默认底层容器 vector<T>，默认 Less → 大堆。
向上调整 + 向下调整：完全使用仿函数解耦，不写死大小比较。
支持：普通类型 / 对象 / 对象指针：全部能正确比较、正确建堆。

3. 模板分离编译

3.1 什么是分离编译

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

3.2 模板的分离编译问题

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

cpp 复制代码

// a.h
// 声明了一个函数模板 Add；作用：支持任意类型相加；只有声明，没有实现
template<class T>
T Add(const T& left, const T& right);

// a.cpp
// 包含头文件，给出 Add 模板的实现，但没有实例化任何函数
#include "a.h"
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<int>
    Add(1.0, 2.0);  // 期望调用Add<double>
    return 0;
}

分析：

C/C++程序要运行，一般要经历以下步骤：预处理 ---> 编译 ---> 汇编 ---> 链接

• 编译：对程序按照语言特性进行词法、语法、语义分析，错误检查无误后生成汇编代码。注意，头文件不参与编译，编译器对工程中的多个源文件是分离开单独编译的。

• 链接：将多个obj文件合并成一个，并处理没有解决的地址问题。

问题所在：

• 在 a.cpp 中，编译器没有看到对 Add 模板函数的显式实例化，因此不会生成具体的加法函数。

• 在 main.obj 中，调用了 Add<int> 与 Add<double>，编译器在链接时才会找其地址，但这两个函数没有实例化，没有生成具体代码，因此链接时报错。

核心原理：

重要规则：模板只有在被使用时，才会实例化具体函数。

编译过程：

① 编译 a.cpp：编译器看到：

cpp 复制代码

template<class T>
T Add(...) { ... }

它不会生成任何代码，因为没有人调用 Add 或 Add， a.obj 里没有 Add 函数的二进制代码

② 编译 main.cpp ：编译器看到：Add(1, 2);

它只看到声明，看不到实现；它会在符号表记下：我需要 Add<int>我需要 Add<double>；但它不会去 a.cpp 里找实现

③ 链接阶段：链接器发现：

• main.cpp 调用了 Add 和 Add；但整个项目里根本没有生成这两个函数 → 报链接错误！

结论：模板不支持分离编译！声明和实现分开在 .h 和 .cpp 中一定会链接失败。

3.3 解决方法

方法1：将声明和实现都放在 .h 中（最常用、推荐）

cpp 复制代码

// Add.h
#pragma once

template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
// 只要传入的类型支持 + 运算，就能编译；int → 整数加法、double → 浮点数加法
// string → 字符串拼接、自定义类型如果重载了 operator+ 也能用
}

模板声明 + 实现都写在 .h 里，编译器看到模板 + 实现，调用时就地实例化，不会报链接错误

这是 C++ 模板最标准、最安全、最推荐的写法。

调用示例：

cpp 复制代码

#include "Add.h"

int main()
{
    // T 被推导为 int
    cout << Add(1, 2) << endl;

    // T 被推导为 double
    cout << Add(1.1, 2.2) << endl;

    return 0;
}

总结：这段代码是一个通用加法函数模板：支持任意类型相加，声明和实现放在同一个头文件，编译器自动推导类型、自动生成对应函数，安全、通用、无链接错误。

方法2：在 .cpp 文件中显式实例化（不推荐）

cpp 复制代码

template int Add<int>(const int&, const int&);
template double Add<double>(const double&, const double&);

它是干嘛的？用来解决"模板分离编译报链接错误"的问题。

你之前把：声明放在 .h，实现放在 .cpp

编译器在编译 .cpp 时不知道要生成什么类型，所以什么函数都不生成，最后链接失败。

加上这两句，就是手动告诉编译器：你给我把 Add<int> 和 Add<double> 这两个函数真的编译出来！

cpp 复制代码

template int Add<int>(const int&, const int&);
// 让编译器强制生成 int 版本的 Add 函数，等价于：
int Add(const int& left, const int& right)
{
    return left + right;
}

template double Add<double>(const double&, const double&);
// 让编译器强制生成 double 版本的 Add 函数

放在哪里用？必须放在 Add.cpp 实现文件的最后：

cpp 复制代码

// Add.cpp
#include "Add.h"

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

// 显式实例化
template int Add<int>(const int&, const int&);
template double Add<double>(const double&, const double&);

main.cpp 调用 Add<int> 和 Add<double>，链接器能找到已经生成好的函数，不再报链接错误。

总结：显式实例化 = 手动生成指定类型的模板函数，作用：让分离编译的模板能正常链接，缺点：每加一种类型就要多写一行，所以真实项目几乎不用，大家都直接把模板写在 .h 里。

法3：包含 cpp（不推荐）

cpp 复制代码

#include "a.cpp"

总结：模板的实例化是在编译期完成的。如果声明和实现分离，编译器看不到实现，就不会实例化，最终导致链接失败。所以，模板的声明和实现必须放在同一个头文件（.h）中。

4. 模板总结

【优点】

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

【缺陷】

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

至此，我们系统梳理了 C++ 模板的三大核心板块：非类型模板参数的编译期常量特性、模板特化的边界处理方案，以及分离编译的工程化解决策略。模板作为泛型编程的灵魂，其价值不仅在于代码复用，更在于在类型安全的前提下兼顾了极致的性能。希望本文的实例与解析，能帮助你扫清模板学习中的盲点，在后续的 STL 源码探究或自定义通用组件开发中，真正做到知其然并知其所以然。