C++ 模板进阶：非类型参数、特化与分离编译详解

2.2 函数模板特化

2.2.1 结论

函数特化其实不如去写普通函数，但是特化版本怎么写要知道。

2.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.2.3 函数模板的特点

特点：如果说这里没有特化，就会实例化这个地方的原模版。

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

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

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

2.3.4 类模板特化应用示例（二）：结合优先级队列实现

（此处省略具体运行截图，逻辑同上）

2.4 偏特化的两种表现方式

2.4.1 部分特化

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

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

2.4.2 参数更进一步的限制

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

//两个参数偏特化为指针类型
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); // 调用特化的指针版本
}

3 模版分离编译

3.1 分离编译的概念

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

3.2 模板的分离编译

3.2.1 模板分离代码简单演示

a.h：

#pragma once
template<class T> T TAdd(const T& left, const T& right) {
    return left + right;
}
int Add(int x, int y);

a.cpp：

#define _CRT_SECURE_NO_WARNINGS 1
#include"a.h"
//// 预处理：展开头文件
//template<class T> //T TAdd(const T& left, const T& right) //{ // return left + right; //}
int Add(int x, int y) {
    return x + y;
}
//// 不用< >
//template //double TAdd(const double& left, const double& right);
template int TAdd(const int& left, const int& right);

main.cpp：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include"a.h"
int main() {
    cout << Add(1, 2) << endl;
    cout << TAdd(1.1, 2.2) << endl;
    cout << TAdd(1, 2) << endl;
    return 0;
}

3.2.2 分析运行过程

（此处省略运行过程截图）

3.2.3 运行结果

（此处省略运行结果截图）

3.3 解决方法

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

3.4 拓展阅读

关于分离编译，建议查阅相关技术文档了解底层原理。

4 模版总结

4.1 模版的优点

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

4.2 模版的缺陷

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

本文完整代码演示

一、模版进阶完整代码演示

priority_queue.h：

#pragma once
#include<vector>
namespace jqj {
    // -------------也可以用自己写的--------------
    // 仿函数
    template <class T> struct Less {
        bool operator() (const T& x, const T& y) const { return x < y; }
    };
    template <class T> struct Greater {
        bool operator() (const T& x, const T& y) const { return x > y; }
    };
    // ---------------可以用库里面的------------------
    // 默认大的优先级高
    template<class T, class Container = std::vector<T>, class Compare = Less<T>>
    class priority_queue {
    public:
        template<class InputInterator>
        priority_queue(InputInterator first, InputInterator last) :_con(first, last) {
            //建堆 —— 向下调整算法建堆（效率比向上调整建堆高）
            for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--) {
                adjust_down(i);
            }
        }
        // 强制编译器生成默认构造
        priority_queue() = default;
        void adjust_up(int child) {
            Compare com;
            int parent = (child - 1) / 2;
            while (child > 0) {
                if (com(_con[parent], _con[child])) {
                    swap(_con[child], _con[parent]);
                    child = parent;
                    parent = (child - 1) / 2;
                } else {
                    break;
                }
            }
        }
        void adjust_down(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 push(const T& x) {
            _con.push_back(x);
            adjust_up(_con.size() - 1);
        }
        void pop() {
            swap(_con[0], _con[_con.size() - 1]);
            _con.pop_back();
            adjust_down(0);
        }
        const T& top() const { return _con[0]; }
        bool empty() const { return _con.empty(); }
        size_t size() const { return _con.size(); }
    private:
        Container _con;
    };
}

queue.h：

#pragma once
#include<vector>
#include<list>
#include<deque>
namespace bit {
    // 容器适配器
    // deque：双端队列
    template<class T, class Container = deque<T>>
    class queue {
    public:
        void push(const T& x) { _con.push_back(x); }
        void pop() { _con.pop_front(); }
        const T& front() { return _con.front(); }
        const T& back() { return _con.back(); }
        size_t size() const { return _con.size(); }
        bool empty() const { return _con.empty(); }
    private:
        Container _con;
    };
}

stack.h：

#pragma once
#include<vector>
#include<list>
#include<deque>
namespace bit {
    template<class T, class Container = deque<T>>
    class stack {
    public:
        void push(const T& x) { _con.push_back(x); }
        void pop() { _con.pop_back(); }
        const T& top() { return _con.back(); }
        size_t size() const { return _con.size(); }
        bool empty() const { return _con.empty(); }
    private:
        Container _con;
    };
}

Test.cpp：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;
#include"stack.h"
#include"queue.h"
#include<deque>
#include"priority_queue.h"

// ------------------目前 C++20 就支持整型、浮点型等等----------------------
// 指针是支持的
// 基本类型、内置类型是支持的，但是自定义类型是不支持的
template<int N,int* ptr> class AA {};

// 现代 C++ 会提到自定义类型、类类型可以定义成常量
// 可以给缺省参数
template<class T, size_t N = 10>
class Stack {
private:
    T _a[N];
    int _top;
};

// ------------------------C++标准库里面有两个类型用了非类型模版参数-------------------------------
#include<array>
// 用非类型模版参数，一个就是 array
// C++ 里面定义的一个静态数组
// array 支持迭代器，就支持范围 for
// 3、再一个就是传参，传参是个大坑——不允许传递数组，因此会退化成指针
// 因为在 C 语言里面，数组的效率是很低的，所有的数组传递都是传指针
void func(int* a,int n) // 数组大小
{
    // 不能使用访问 for
    //for (auto e : a) { cout << e << " "; }
    //cout << endl;
}
void func(const array<int,10>& a) {
    // 能使用访问 for
    for (auto e : a) {
        cout << e << " ";
    }
    cout << endl;
}

// ------------------------------模版的特化------------------------------------
// =======================函数模版的特化=======================
// 特化，即特殊化处理
// 日期类：比较大小
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);
private:
    int _year;
    int _month;
    int _day;
};

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

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

// 对上述函数模版实现一个特化版本
template<> bool Less<Date*>(Date* left, Date* right) {
    return *left < *right;
}

//int main() {
//    cout << Less(1, 2) << endl;
//    Date* p1 = new Date(2025, 1, 1);
//    Date* p2 = new Date(2025, 1, 3);
//    cout << Less(p1, p2) << 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, double> {
public:
    Data() { cout << "Data<int,double> 特化" << endl; }
    void func() {};
};

// 半特化/偏特化
template<class T1> class Data <T1, double> {
public:
    Data() { cout << "Data<T1,double> 特化" << endl; }
    void func() {};
};

// --------------------半特化的另一种用法，对参数类型进行限制-------------------------
// 限制实例化参数是指针
template<class T1,class T2> class Data <T1*, T2*> {
public:
    Data() { cout << "Data<T1*, T2*> 特化" << endl; }
    void func() {
        cout << typeid(T1).name() << endl;
        cout << typeid(T2).name() << endl;
    }
};

// 除了是指针，还可以是引用
template<class T1, class T2> class Data <T1&, T2&> {
public:
    Data() { cout << "Data<T1&, T2&> 特化" << endl; }
    void func() {
        cout << typeid(T1).name() << endl;
        cout << typeid(T2).name() << endl;
    }
};

// 也可以混在一起
template<class T1, class T2> class Data <T1*, T2&> {
public:
    Data() { cout << "Data<T1*, T2&> 特化" << endl; }
    void func() {
        cout << typeid(T1).name() << endl;
        cout << typeid(T2).name() << endl;
    }
};

// 甚至于说第一个是指针，第二是整型 int
template<class T1> class Data <T1*, int> {
public:
    Data() { cout << "Data<T1*, int> 特化" << endl; }
    void func() {
        cout << typeid(T1).name() << endl;
    }
};

//int main() {
//    Data<int, int> d1;
//    Data<int, double> d2; d2.func();
//    Data<char*, double*> d4; d4.func();
//    Data<char&, double&> d5; d5.func();
//    Data<char*, int> d6; d6.func();
//    return 0;
//}

// -------------------有了特化的用法，就可以把前面的用法改造一下----------------------
namespace jqj {
    // 偏特化版本，所有的指针都按指针指向的内容去比较
    template<class T> struct Less<T*> {
        bool operator() (const T* x, const T* y) const {
            return *x < *y;
        }
    };
    template<> struct Greater<Date*> {
        bool operator() (const Date* x, const Date* y) const {
            return *x > *y;
        }
    };
}

int main() {
    jqj::priority_queue<Date*> pq;
    pq.push(new Date(2025, 10, 18));
    pq.push(new Date(2025, 10, 19));
    pq.push(new Date(2025, 10, 17));
    while (!pq.empty()) {
        cout << *pq.top() << " ";
        pq.pop();
    }
    cout << endl;
    return 0;
}

二、模版分离完整代码演示

a.h：

#pragma once
template<class T> T TAdd(const T& left, const T& right) {
    return left + right;
}
int Add(int x, int y);

a.cpp：

#define _CRT_SECURE_NO_WARNINGS 1
#include"a.h"
int Add(int x, int y) {
    return x + y;
}
template int TAdd(const int& left, const int& right);

main.cpp：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include"a.h"
int main() {
    cout << Add(1, 2) << endl;
    cout << TAdd(1.1, 2.2) << endl;
    cout << TAdd(1, 2) << endl;
    return 0;
}

结尾

感谢阅读。