C++泛型编程之类模板

前言

C++的泛型编程是指通过使用模板技术来实现通用的代码，使得同一段代码可以适用于不同类型的数据，从而提高代码的重用性和灵活性。

在C++中，泛型编程主要通过使用函数模板和类模板来实现。函数模板是一种允许定义通用函数的机制，它可以接受不同类型的参数，并根据实际参数类型推导出最适合的函数实例。类模板允许定义通用类，其中的成员函数和成员变量可以具有通用的类型，从而使得同一套代码适用于不同类型的对象。

泛型编程的优势在于可以提高代码的可重用性和可扩展性。通过编写泛型代码，开发人员可以减少代码的冗余，减少维护工作，并且可以将关注点集中在算法和逻辑上，而不是为每个特定类型编写特定的代码。此外，泛型编程还能提供更好的类型安全性，因为编译器会对模板参数的类型进行检查。

一、类模板

类模板（Class Template）是一种通用的类描述，它允许您定义一个可以用于多种不同数据类型的类模板。类模板为类定义提供了参数化的通用形式，以便在代码中可以根据需要实例化具体的类型。

类模板的语法形式如下：

template <typename T>
class ClassName {
    // 类的成员和方法声明/定义
};

在上述的语法中，`T` 是一个类型参数，它可以表示任何合法的数据类型（例如整数、浮点数、自定义类型等）。您可以使用多个类型参数，并在类的成员和方法的声明/定义中使用这些类型参数。

在使用类模板时，需要根据所需的具体类型进行实例化，例如：

ClassName<int> obj1;   // 使用 int 实例化类模板
ClassName<double> obj2;   // 使用 double 实例化类模板

通过类模板，您可以提供通用的类定义来处理相似类型的不同数据。这样可以避免重复编写相似的代码，提高代码的重用性和灵活性。

需要注意的是，类模板只是定义了一个模板，实际的类对象是通过模板参数进行实例化生成的。这意味着不同类型的实例化会生成不同的类对象，它们具有相同的模板结构，但对应不同的类型进行了参数化。

二、类模板特化

类模板特化（Class Template Specialization）是指为特定的类型或特定的模板参数提供一个定制的模板实现。通过特化，您可以针对特定需求，为某些特定类型或参数提供一个不同于通用模板的实现，以满足特定情况下的特殊需求。

特化可以分为两种类型：全特化（Full Specialization）和偏特化（Partial Specialization）。

1. 全特化：对于给定的类型或参数，提供一个完全特定化的模板实现。全特化的模板实现将完全替代通用模板实现。语法形式如下：

template <>
class ClassName<SpecificType> {
    // 特化的成员和方法声明/定义
};

在上述语法中，`SpecificType` 是特化针对的类型，`ClassName` 是要特化的类模板。

2. 偏特化：对于给定的类型或参数，提供一个部分特化的模板实现。偏特化允许您根据特定的条件或特征，为模板的某些参数提供一个特定化的实现，但仍保留了一些通用特性。语法形式如下：

template <typename T, typename U, ...>
class ClassName<T, U, ...> {
    // 偏特化的成员和方法声明/定义
};

在上述语法中，`T`, `U`, ... 是模板参数列表，`ClassName` 是要偏特化的类模板。

2.1 C++代码示例

// 类模板
template <typename T>
class MyTemplateClass {
public:
    MyTemplateClass(const T& value) : data(value) {}
    void print() {
        std::cout << "Generic Template: " << data << std::endl;
    }
private:
    T data;
};
// 全特化
template <>
class MyTemplateClass<int> {
public:
    MyTemplateClass(const int& value) : data(value) {}
    void print() {
        std::cout << "Specialized Template for int: " << data << std::endl;
    }
private:
    int data;
};
// 偏特化
template <typename T, typename U>
class MyTemplateClass<T, U> {
public:
    MyTemplateClass(const T& value1, const U& value2) : data1(value1), data2(value2) {}
    void print() {
        std::cout << "Partial Specialization for two types: " << data1 << ", " << data2 << std::endl;
    }
private:
    T data1;
    U data2;
};
int main() {
    MyTemplateClass<double> genericObj(3.14);
    genericObj.print(); // Output: Generic Template: 3.14
    MyTemplateClass<int> specializedObj(42);
    specializedObj.print(); // Output: Specialized Template for int: 42
    MyTemplateClass<std::string, char> partialObj("Hello", 'W');
    partialObj.print(); // Output: Partial Specialization for two types: Hello, W
    return 0;
}

在上述示例代码中，我们定义了一个通用的类模板 MyTemplateClass，该模板接受一个类型参数。然后我们分别进行了全特化和偏特化的示例。

全特化示例中，我们为 MyTemplateClass<int> 提供了一个完全特化的实现，该特化版本使用 int 类型来处理数据，并提供了特定的打印方法。

偏特化示例中，我们为 MyTemplateClass<T, U> 提供了一个偏特化的实现，该特化版本接受两个类型参数，并进行特殊的处理和打印。

三、默认模板参数

类模板的默认模板参数是指在定义类模板时，为一个或多个模板参数提供默认值。这样，当实例化类模板时，如果没有显式地指定对应参数的具体值，则将使用默认的模板参数值。

默认模板参数的使用可以使类模板更加灵活，并提供更方便的使用方式。

示例代码：

template <typename T = int, int N = 5>
class MyTemplateClass {
public:
    void print() {
        std::cout << "Type: " << typeid(T).name() << ", Value: " << N << std::endl;
    }
};

在上述示例中，我们定义了一个名为 `MyTemplateClass` 的类模板，并为类型参数 `T` 和非类型参数 `N` 提供了默认值。具体来说，类型参数 `T` 的默认值为 `int`，非类型参数 `N` 的默认值为 `5`。

我们可以使用以下方式实例化 `MyTemplateClass` 类模板：

MyTemplateClass<> obj1;
MyTemplateClass<float> obj2;
MyTemplateClass<double, 10> obj3;

在这些实例化中，使用了不同的模板参数，并观察了打印出的类型和值。

对于 `obj1` 的实例化，由于没有显式指定模板参数，因此将使用默认的模板参数，即 `T` 类型为 `int`，`N` 值为 `5`。

对于 `obj2` 的实例化，只指定了类型参数 `T` 为 `float`，使用的是默认的非类型参数 `N` 值 `5`。

对于 `obj3` 的实例化，同时指定了类型参数 `T` 为 `double`，非类型参数 `N` 值为 `10`。

通过使用默认模板参数，我们可以优化类模板的使用方式，并避免在某些情况下需要显式指定模板参数值的繁琐性。

四、类模板中的成员模板

类模板的成员模板是指在类模板内部定义的一个可以根据需要进行模板化的成员函数或成员方法。成员模板允许在类模板内定义一个泛型成员函数，以适应不同的类型或模板参数。

通过成员模板，可以实现更加灵活和通用的功能，因为成员模板可以针对不同的类型或模板参数进行特化，为每个特定的实例提供适当的实现。

类模板的成员模板的用法：

template <typename T>
class MyTemplateClass {
public:
    template <typename U>
    void print(U value) {
        std::cout << "Type T: " << typeid(T).name() << ", Type U: " << typeid(U).name() << ", Value: " << value << std::endl;
    }
};

在上述示例中，我们定义了一个名为 `MyTemplateClass` 的类模板，并在类模板内部定义了一个成员模板 `print`。该成员模板接受一个类型参数 `U`，并在打印信息时展示了类型 `T` 和 `U`，以及传入的值。

我们可以使用以下方式使用成员模板：

MyTemplateClass<int> obj;
obj.print(3.14); // Type T: int, Type U: double, Value: 3.14
obj.print("Hello"); // Type T: int, Type U: const char*, Value: Hello

在上述示例中，我们首先实例化了类模板 `MyTemplateClass` 为 `MyTemplateClass<int>`。然后，我们对实例 `obj` 使用了成员模板的 `print` 方法，并传入了不同类型的参数。

在第一个使用示例中，传入的参数类型为 `double`，因此 `U` 被推断为 `double`，并打印出了对应的类型信息。

在第二个使用示例中，传入的参数类型为 `const char*`，因此 `U` 被推断为 `const char*`，并打印出了对应的类型信息。

五、类模板别名

类模板的模板别名是指使用 `using` 关键字给类模板的模板参数取一个别名。这样可以简化复杂的模板参数名称，提高代码的可读性和可维护性。

类模板的模板别名的用法：

template <typename T>
class MyTemplateClass {
public:
    using DataType = T; // 模板别名
    DataType getData() {
        return data;
    }
private:
    DataType data;
};

在上述示例中，我们定义了一个名为 `MyTemplateClass` 的类模板，并使用 `using` 关键字为类型参数 `T` 定义了一个别名 `DataType`。

在类模板中，我们使用 `DataType` 作为私有数据成员 `data` 的类型，并在 `getData` 成员函数中返回该类型的值。

通过使用模板别名，可以简化并提高代码的可读性。

实例化类模板和使用模板别名：

MyTemplateClass<int> obj;
obj.getData(); // 返回 int 类型的数据
MyTemplateClass<double> obj2;
obj2.getData(); // 返回 double 类型的数据

在上述示例中，我们实例化了 `MyTemplateClass` 类模板为 `MyTemplateClass<int>` 和 `MyTemplateClass<double>`，并使用 `getData` 成员函数获取相应类型的数据。

通过使用模板别名 `DataType`，我们可以使用简洁而直观的方式访问和使用模板类的类型参数。这可以提高代码的可读性和可维护性，尤其是当模板参数名称较长或复杂时。

五、类模板的可变参数模板

类模板的可变参数模板是指在类模板定义中使用可变数量的模板参数。可变参数模板允许以更灵活的方式定义接受任意数量参数的模板类。

使用可变参数模板时，可以通过使用省略号 `...` 表示一个参数包，该参数包可以接受任意数量的模板参数。通过参数包展开，可以在类模板的定义中对每个参数进行操作。

类模板的可变参数模板的用法：

template <typename... Args>
class MyTemplateClass {
public:
    void printArgs(Args... args) {
        print(args...);
    }
private:
    void print() {}
    template <typename T, typename... Rest>
    void print(T first, Rest... rest) {
        std::cout << first << " ";
        print(rest...);
    }
};

在上述示例中，我们定义了一个名为 `MyTemplateClass` 的类模板，使用了可变参数模板 `Args`。该类有一个成员函数 `printArgs`，接受任意数量的参数，并将这些参数传递给另一个内部的递归模板函数 `print`。

函数 `print` 用于打印传入的参数。在递归过程中，每次我们打印第一个参数，并递归调用 `print` 函数来处理剩余的参数，直到参数包为空。

我们可以使用以下方式使用可变参数模板类：

MyTemplateClass<int, double, std::string> obj;
obj.printArgs(10, 3.14, "Hello"); // 输出：10 3.14 Hello

在上述示例中，我们将 `MyTemplateClass` 实例化为接受 `int`、`double` 和 `std::string` 类型参数的类模板。然后，我们使用成员函数 `printArgs` 并传递整数、浮点数和字符串作为参数。在输出中，参数被递归打印出来。

通过使用可变参数模板，可以定义接受任意数量参数的类模板，并对每个参数进行相应的操作和处理。这种灵活性使得类模板更加通用和适用于各