C++ 模板机制详解：参数、特化与分离编译

2. 代码案例

下面是一个使用非类型参数定义静态数组模板类的示例：

namespace mySpace {
    template<class T, size_t N = 10>
    class array {
    private:
        T _array[N];      // 编译期确定大小
        size_t _size;     // 记录有效元素数量
    public:
        T& operator[](size_t index) {
            return _array[index];
        }
        const T& operator[](size_t index) const {
            return _array[index];
        }
        size_t size() const {
            return _size;
        }
        bool empty() const {
            return _size == 0;
        }
    };
}

三、模板模板参数

模板模板参数是指将模板本身作为参数传递给另一个模板。这在某些高级泛型场景（如容器适配器）中非常有用，虽然相对少见，但理解其概念有助于掌握更复杂的模板设计。

模板特化

模板特化（Template Specialization）允许针对特定的模板参数类型提供定制化实现，解决通用模板在特殊场景下的不足。

1. 什么是模板特化？

当通用模板在某些特定类型下需要不同的行为或更高效的实现时，特化可以让代码更灵活。例如，比较两个日期对象的内容与比较两个指针的地址，逻辑截然不同。

2. 为什么要使用模板特化？

看一个实际例子。我们定义了一个通用的比较函数模板 Less，它依赖操作符 <。对于普通类型和重载了 < 的类，它能正常工作。但对于指针，直接比较的是内存地址而非对象内容。

#include <iostream>
using namespace std;

class Date {
public:
    int _year, _month, _day;
    Date(int y, int m, int d) : _year(y), _month(m), _day(d) {}
    bool operator<(const Date& other) const {
        if (_year != other._year) return _year < other._year;
        if (_month != other._month) return _month < other._month;
        return _day < other._day;
    }
};

template<class T>
bool Less(T x, T y) {
    return x < y;
}

int main() {
    Date d1(2022, 7, 7), d2(2022, 7, 8);
    Date* p1 = &d1, *p2 = &d2;
    
    cout << Less(d1, d2) << endl; // 正确：比较对象内容
    cout << Less(p1, p2) << endl; // 潜在问题：比较指针地址
    return 0;
}

在这个例子中，Less(p1, p2) 比较的是 p1 和 p2 的地址，而不是它们指向的 Date 对象的时间先后。这时就需要对模板进行特化处理。

3. 模板特化的分类

一、函数模板特化

1. 全特化

为函数模板的所有参数显式指定类型。例如，针对 const char* 字符串比较，我们需要比较内容而非地址。

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

template<typename T>
T max_val(T a, T b) {
    return a > b ? a : b;
}

// 针对 const char* 的全特化
template<>
const char* max_val<const char*>(const char* a, const char* b) {
    return strcmp(a, b) > 0 ? a : b;
}

int main() {
    cout << max_val(10, 20) << endl;
    const char* s1 = "apple", *s2 = "banana";
    cout << max_val(s1, s2) << endl; // 输出 banana
    return 0;
}

2. 偏特化

注意：C++ 标准不支持函数模板的偏特化。如果需要对部分参数进行特化，通常通过函数重载来实现类似效果。

#include <iostream>
using namespace std;

template<class T>
T max_val(T a, T b) {
    return a > b ? a : b;
}

// 重载版本：针对指针类型（模拟偏特化）
template<class T>
T* max_val(T* a, T* b) {
    return *a > *b ? a : b;
}

int main() {
    int x = 10, y = 20;
    cout << max_val(5, 3) << endl;          // 调用通用模板
    int* result = max_val(&x, &y);          // 调用重载版本
    cout << *result << endl;
    return 0;
}

在实际开发中，由于函数模板偏特化语法受限且复杂，建议优先考虑函数重载或类模板特化。

二、类模板特化

1. 全特化

为类模板的所有参数显式指定类型。

#include <iostream>
using namespace std;

template<class T, size_t N = 10>
class MyContainer {
public:
    MyContainer() { cout << "通用类模板构造" << endl; }
    void print() { cout << "通用容器" << endl; }
};

// 全特化
template<>
class MyContainer<int, 10> {
public:
    MyContainer() { cout << "全特化类构造" << endl; }
    void print() { cout << "特化容器：专门存储 int" << endl; }
};

int main() {
    MyContainer<double, 5> c1;
    MyContainer<int, 10> c2;
    return 0;
}

2. 偏特化

对模板参数的部分类型或特定条件进行特化。常见场景包括参数数量特化和参数范围特化（如指针、const）。

#include <iostream>
using namespace std;

template<class T, size_t N = 10>
class MyContainer {
public:
    MyContainer() { cout << "通用类模板构造" << endl; }
    void print() { cout << "通用容器" << endl; }
};

// 针对指针类型的偏特化
template<class T, size_t N>
class MyContainer<T*, N> {
public:
    MyContainer(T* data) : _data(data) {
        cout << "偏特化类构造（指针类型）" << endl;
    }
    void print() { cout << "存储指针：地址 = " << _data << endl; }
private:
    T* _data;
};

int main() {
    int x = 100;
    MyContainer<int*> c2(&x); // 调用偏特化版本
    c2.print();
    return 0;
}

分离编译

什么是分离编译？

分离编译是一种软件开发策略，将程序的不同部分分别编译为目标文件，最后由链接器合并。核心在于声明与定义的分离：头文件放声明，源文件放实现。

模板的分离编译问题

模板的分离编译容易引发链接错误。这是因为模板代码本身不是完整代码，只有在被实例化时才会生成具体代码。如果模板定义放在 .cpp 文件中，而其他文件只包含声明，编译器无法生成对应的实例化代码，导致链接器找不到符号。

/* func.h */
template<class T> void func(T x);

/* func.cpp */
#include "func.h"
template<class T> void func(T x) { /* ... */ }

/* main.cpp */
#include "func.h"
int main() {
    func(42); // 链接错误：找不到 func<int> 的定义
    return 0;
}

解决方案

主要有两种方法：

1. 将模板定义放在头文件中（推荐） 让编译器在使用模板的编译单元同时看到声明和定义，从而直接实例化。

   /* func.h */
   template<class T>
   void func(T x) { /* 直接在头文件中定义 */ }
   

2. 使用显式实例化 在模板定义文件中显式指定需要实例化的类型，强制编译器生成对应代码。

   /* func.cpp */
   #include "func.h"
   template<class T> void func(T x) { /* ... */ }
   template void func<int>(int); // 显式实例化
   

第一种方法简单直接，兼容性最好；第二种方法适合需要严格控制接口暴露的场景，但需预先知道所有使用类型。