再识C++模板

模板编程是C++中强大且灵活的特性，它允许在编译时实现泛型编程，以便在不同数据类型上重用代码。我们将深入探讨C++中的非类型模板参数、类模板的特化以及模板的分离编译，并附上代码示例来帮助更好地理解这些概念。

1. 非类型模板参数

C++中的模板不仅可以具有类型参数，还可以有非类型参数。非类型模板参数是指在模板中传递的常量表达式参数，它们可以是整数、指针、引用或枚举类型等。在定义模板时，我们可以用非类型参数作为模板参数来实现对常量表达式的泛型支持。

以一个简单的例子来说明非类型模板参数的用法：

#include <iostream>

// 非类型模板参数的示例：计算数组的平均值
template <typename T, int size>
T CalculateAverage(const T (&arr)[size]) {
    T sum = 0;
    for (int i = 0; i < size; ++i) {
        sum += arr[i];
    }
    return sum / size;
}

int main() {
    int intArray[] = {1, 2, 3, 4, 5};
    double doubleArray[] = {1.1, 2.2, 3.3, 4.4, 5.5};

    std::cout << "Average of intArray: " << CalculateAverage(intArray) << std::endl;
    std::cout << "Average of doubleArray: " << CalculateAverage(doubleArray) << std::endl;

    return 0;
}

在上述示例中，我们定义了一个函数模板`CalculateAverage`，它有两个模板参数：`T`为类型参数，用于指定数组元素的类型；`size`为非类型参数，用于指定数组的大小。函数模板通过非类型参数`size`实现了对不同大小的数组进行平均值计算的泛型支持。

2. 类模板的特化

类模板特化是指为特定类型的参数提供专门的实现。当我们在模板中针对特定类型或特定条件编写代码时，可以使用类模板的特化来覆盖通用模板，从而提供更具体化的实现。

类模板特化可以分为两种类型：全特化和偏特化。

2.1 函数模板特化

函数模板特化允许我们为特定类型的参数提供专门的实现。要创建函数模板特化，我们需要使用`template<>`来声明特化版本，并在括号内提供具体的类型。

让我们通过一个示例来说明函数模板特化的用法：

#include <iostream>

// 通用的add函数模板
template <typename T>
T Add(T a, T b) {
    std::cout << "Using generic Add function." << std::endl;
    return a + b;
}

// int类型的add函数模板特化
template <>
int Add<int>(int a, int b) {
    std::cout << "Using specialized Add function for int." << std::endl;
    return a + b;
}

int main() {
    double x = 1.5, y = 2.5;
    int p = 5, q = 10;

    std::cout << "Generic Add result: " << Add(x, y) << std::endl; // 使用通用的Add函数模板
    std::cout << "Specialized Add result: " << Add(p, q) << std::endl; // 使用特化的Add函数模板

    return 0;
}

在上面的代码中，我们首先定义了一个通用的`Add`函数模板，用于执行通用类型的加法操作。然后，我们为`int`类型提供了特化版本的`Add`函数模板，以提供针对`int`类型的特殊实现。当我们调用`Add`函数时，编译器将自动选择正确的版本，即通用模板或特化模板。

2.2 类模板特化

类模板特化允许我们为特定类型的参数提供专门的实现。与函数模板特化类似，我们使用`template<>`来声明类模板的特化版本，并在括号内提供具体的类型。

类模板特化可以进一步分为全特化和偏特化：

2.2.1 全特化

全特化是指为模板提供了完整的特化版本，包括所有的模板参数。

让我们通过一个示例来说明类模板的全特化：

#include <iostream>

// 通用的Pair类模板
template <typename T1, typename T2>
class Pair {
public:
    Pair(T1 first, T2 second) : first_(first), second_(second) {}

    void Print() const {
        std::cout << "(" << first_ << ", " << second_ << ")" << std::endl;
    }

private:
    T1 first_;
    T2 second_;
};

// Pair类模板的全特化版本
template <>
class Pair<int, double> {
public:
    Pair(int first, double second) : first_(first), second_(second) {}

    void Print() const {
        std::cout << "(" << first_ << ", " << second_ << ") - specialized" << std::endl;
    }

private:
    int first_;
    double second_;
};

int main() {
    Pair<int, int> p1(1, 2);
    Pair<int, double> p2(3, 4.5);

    p1.Print(); // 使用通用的Pair类模板
    p2.Print(); // 使用全特化的Pair类模板

    return 0;
}

在上述示例中，我们首先定义了一个通用的`Pair`类模板，用于表示一对值。然后，我们为类型`int`和`double`提供了全特化版本的`Pair`类模板，以提供针对这些特定类型的特殊实现。在`main`函数中，我们分别创建了一个通用版本和一个特化版本的`Pair`对象，并调用它们的`Print`函数。

2.2.2 偏特化

偏特化是指为模板提供了部分特化版本，只涉及到部分模板参数。

让我们通过一个示例来说明类模板的偏特化：

#include <iostream>

// 通用的Pair类模板
template <typename T1, typename T2>
class Pair {
public:
    Pair(T1 first, T2 second) : first_(first), second_(second) {}

    void Print() const {
        std::cout << "(" << first_ << ", " << second_ << ")" << std::endl;
    }

private:
    T1 first_;
    T2 second_;
};

// Pair类模板的偏特化版本（针对指针类型）
template <typename T>
class Pair<T*, T*> {
public:
    Pair(T* first, T* second) : first_(first), second_(second) {}

    void Print() const {
        std::cout << "(" << *first_ << ", " << *second_ << ") - specialized" << std::endl;
    }

private:
    T* first_;
    T* second_;
};

int main() {
    int a = 1, b = 2;
    double x = 1.1, y = 2.2;

    Pair<int, int> p1(&a, &b);
    Pair<double, double> p2(&x, &y);

    p1.Print(); // 使用通用的Pair类模板
    p2.Print(); // 使用偏特化的Pair类模板

    return 0;
}

在上述示例中，我们首先定义了一个通用的`Pair`类模板，用于表示一对值。然后，我们为指针类型提供了偏特化版本的`Pair`类模板，以提供针对指针类型的特殊实现。在`main`函数中，我们分别创建了一个通用版本和一个偏特化版本的`Pair`对象，并调用它们的`Print`函数。

2.2.3 类模板特化应用示例

让我们通过一个更实际的示例来演示类模板特化的应用。假设我们需要一个动态数组类模板，允许在编译时指定数组的类型和大小，同时提供了特化版本来处理指针类型。

#include <iostream>
#include <memory>

// 通用的动态数组类模板
template <typename T, int size>
class DynamicArray {
public:
    DynamicArray() {
        data_ = std::make_unique<T[]>(size);
        for (int i = 0; i < size; ++i) {
            data_[i] = T();
        }
    }

    T& operator[](int index) {
        return data_[index];
    }

private:
    std::unique_ptr<T[]> data_;
};

// 动态数组类模板的偏特化版本（针对指针类型）
template <typename T>
class DynamicArray<T*, 0> {
public:
    DynamicArray(T* ptr) : data_(ptr) {}

    T& operator[](int index) {
        return data_[index];
    }

private:
    T* data_;
};

int main() {
    DynamicArray<int, 5> arr1; // 创建一个包含5个int类型元素的动态数组
    arr1[2] = 42;
    std::cout << "arr1[2]: " << arr1[2] << std::endl;

    int rawIntArray[] = {1, 2, 3, 4, 5};
    DynamicArray<int*, 0> arr2(rawIntArray); // 创建一个指向现有数组的动态数组
    std::cout << "arr2[3]: " << arr2[3] << std::endl;

    return 0;
}

在上述示例中，我们首先定义了一个通用的`DynamicArray`类模板，用于创建动态数组。然后，我们为指针类型提供了偏特化版本的`DynamicArray`类模板，以支持指向现有数组的动态数组。

在`main`函数中，我们分别创建了一个包含5个int类型元素的动态数组和一个指向现有整型数组的动态数组，并演示了它们的用法。

3. 模板的分离编译

在C++中，模板通常定义在头文件中，并且在使用时需要在每个使用模板的源文件中包含相应的头文件。这样做可能导致编译时间增加，因为每次使用模板时，编译器都需要重新实例化模板代码。

为了避免重复编译模板代码，可以使用模板的分离编译。分离编译的基本思想是将模板的声明和实现分开，将模板的声明放在头文件中，而将实现放在单独的源文件中，并确保模板实现的源文件只被编译一次。

让我们通过一个示例来说明模板的分离编译：

假设我们有一个简单的Pair类模板，其声明放在`Pair.h`头文件中，实现放在`Pair.cpp`源文件中。

// Pair.h

#ifndef PAIR_H
#define PAIR_H

template <typename T1, typename T2>
class Pair {
public:
    Pair(T1 first, T2 second) : first_(first), second_(second) {}

    void Print() const;

private:
    T1 first_;
    T2 second_;
};

#include "Pair.cpp"

#endif

// Pair.cpp

#include <iostream>
#include "Pair.h"

template <typename T1, typename T2>
void Pair<T1, T2>::Print() const {
    std::cout << "(" << first_ << ", " << second_ << ")" << std::endl;
}

// 显式实例化模板，以确保Pair类的实现只被编译一次
template class Pair<int, int>;
template class Pair<double, double>;

在上述示例中，我们将Pair类模板的声明放在`Pair.h`头文件中，并将其实现放在`Pair.cpp`源文件中。注意，在`Pair.cpp`源文件末尾，我们显式实例化了模板的两个特化版本，以确保它们的实现只被编译一次。使用时，只需在`main.cpp`源文件中包含`Pair.h`头文件即可：

// main.cpp

#include "Pair.h"

int main() {
    Pair<int, int> p1(1, 2);
    Pair<double, double> p2(1.1, 2.2);

    p1.Print();
    p2.Print();

    return 0;
}

通过模板的分离编译，当我们在多个源文件中使用Pair类模板时，模板的实现只会被编译一次，减少了编译时间和可执行文件的大小。