C++里面的“百变怪”：模板详解-CSDN博客

本文链接：https://blog.csdn.net/qq_42978535/article/details/142762997

C++模板是一种强大的工具，能够实现代码的高复用性和泛型编程。它使得同一份代码可以适应多种数据类型，不必为每种类型单独编写实现。在这篇文章中，我们将深入探讨C++中的模板，理解其基础概念和使用场景，并通过大量代码示例帮助你掌握模板的使用。

一、什么是模板？

模板（Template）是C++中用来编写泛型代码的一种机制。它允许我们在编写函数或类时不指定具体的数据类型，而是在使用时才决定类型，从而实现代码的复用。

1.1 模板的种类

C++中主要有两种模板：

函数模板：用于创建适用于不同数据类型的函数。
类模板：用于创建适用于不同数据类型的类。

下面我们将详细讲解这两种模板的使用。

二、函数模板

函数模板允许你编写一个函数，而无需指定具体的数据类型，在函数调用时根据传入的参数类型来自动推导出数据类型。

2.1 基本语法

定义函数模板的语法如下：

template <typename T>
T add(T a, T b) {
    return a + b;
}

template <typename T> 表示我们定义了一个模板类型T，这个T可以是任意类型，在函数的实现中使用了T类型的参数。我们可以在使用时传入不同的数据类型，例如：

#include <iostream>

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << "int: " << add(2, 3) << std::endl;      // 输出 int: 5
    std::cout << "double: " << add(2.5, 3.1) << std::endl;  // 输出 double: 5.6
    return 0;
}

2.2 模板的类型推导

函数模板支持类型推导，即当你调用模板函数时，编译器会根据传入的参数类型自动推断出模板参数的类型。例如：

int result = add(10, 20);  // 自动推导 T 为 int
double result = add(2.5, 3.7);  // 自动推导 T 为 double

如果你想手动指定模板参数类型，也可以在调用时显式指定：

int result = add<int>(10, 20);

2.3 模板的多类型参数

模板不仅支持一个类型参数，还可以支持多个类型参数。例如：

template <typename T1, typename T2>
void print(T1 a, T2 b) {
    std::cout << a << " and " << b << std::endl;
}

int main() {
    print(10, "hello");  // 输出 10 and hello
    print(3.14, 42);     // 输出 3.14 and 42
}

在这个例子中，我们定义了两个模板参数T1和T2，它们可以分别是不同的类型。

三、类模板

类模板是用于创建适用于不同数据类型的类。它的作用与函数模板类似，但应用于类的定义上。

3.1 基本语法

类模板的定义语法如下：

template <typename T>
class Box {
private:
    T value;
public:
    Box(T v) : value(v) {}
    T getValue() {
        return value;
    }
};

在这个类模板Box中，我们使用模板参数T来定义类中的成员变量和方法。我们可以通过不同的数据类型来实例化这个类模板：

int main() {
    Box<int> intBox(10);
    Box<double> doubleBox(5.5);
    
    std::cout << "intBox value: " << intBox.getValue() << std::endl;  // 输出 intBox value: 10
    std::cout << "doubleBox value: " << doubleBox.getValue() << std::endl;  // 输出 doubleBox value: 5.5
}

3.2 类模板的特化

有时，我们希望对某些特定的类型进行特殊处理，这时可以使用模板特化。模板特化可以为特定类型提供不同的实现。

例子：为`char*`类型特化

template <>
class Box<char*> {
private:
    char* value;
public:
    Box(char* v) : value(v) {}
    char* getValue() {
        return value;
    }
};

int main() {
    Box<char*> strBox("Hello, World!");
    std::cout << "strBox value: " << strBox.getValue() << std::endl;  // 输出 strBox value: Hello, World!
}

在这里，我们为char*类型提供了一个特化版本的Box类，使其行为与其他类型有所不同。

四、模板的优缺点

4.1 模板的优点

代码复用：模板允许我们编写通用的代码，减少代码重复，提高代码的复用性。
类型安全：通过模板，我们可以在编译时检查类型，从而提高类型安全性。
性能：模板在编译时生成具体的代码实现，不引入额外的运行时开销，因此可以带来较高的性能。

4.2 模板的缺点

编译时间较长：由于模板会在编译时展开成具体的代码实现，复杂的模板会增加编译时间。
调试困难：模板代码的错误信息通常比较复杂，不易理解和定位。

五、模板的分离编译

在模板的使用过程中，通常我们将模板的声明和实现放在同一个头文件中，这是因为模板的代码是在编译时生成具体实现的。如果你尝试将模板的实现放到源文件中，可能会遇到链接错误。

解决这个问题的常见方法是将模板的实现放在头文件中，或者使用显式实例化。例如：

template class Box<int>;  // 显式实例化
template class Box<double>;

这种方法告诉编译器为特定的类型生成模板代码。

六、模板的应用场景

6.1 STL中的模板

C++标准模板库（STL）是模板强大应用的经典例子。STL中的容器（如vector、list等）和算法（如sort、find等）都是通过模板实现的。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (int v : vec) {
        std::cout << v << " ";  // 输出 1 2 3 4 5
    }
    std::cout << std::endl;
    return 0;
}

6.2 通过模板实现泛型算法

我们可以通过模板实现一些通用的算法，如排序、查找等。例如，下面是一个使用模板实现的交换函数：

template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10, y = 20;
    swap(x, y);
    std::cout << "x = " << x << ", y = " << y << std::endl;  // 输出 x = 20, y = 10

    double a = 1.5, b = 2.5;
    swap(a, b);
    std::cout << "a = " << a << ", b = " << b << std::endl;  // 输出 a = 2.5, b = 1.5
}