C++模板基础用法 函数与类模板详解

C++模板通过类型参数化实现代码复用和泛型编程。1. 函数模板允许定义通用函数，使用template声明，支持显式或隐式实例化，减少重复逻辑；2. 类模板用于创建可容纳多种数据类型的类，需显式指定类型参数，适用于容器类设计；3. 模板代码通常置于头文件中以避免链接错误；4. typename与class在模板参数中等价，但typename还可用于标识依赖类型；5. 模板解决了代码冗余问题，提升维护性和抽象层次，是标准库容器如vector、map实现的基础。

C++模板，简单来说，就是一种编写通用代码的机制。它允许你定义函数或类时，不指定具体的数据类型，而是用一个占位符代替，等到实际使用时再传入具体的类型。这大大减少了代码重复，提高了灵活性。函数模板用于创建可处理多种数据类型的函数，而类模板则用于创建可容纳多种数据类型的类。声明是定义这个通用蓝图，实例化则是根据蓝图“制造”出具体的产品。

Okay, diving into模板的实际操作。很多时候，写代码写到一半，你可能会发现，哎，这个函数除了处理的数据类型不一样，逻辑几乎一模一样。比如一个简单的求最大值的函数，int版、double版、string版，写起来简直是复制粘贴。这就是模板派上用场的地方。

函数模板的声明与实例化： 声明一个函数模板，你需要在函数签名前面加上 template 或者 template。这里的 T 就是一个类型参数，一个占位符。

#include 
#include 

// 声明一个函数模板
template
T maximum(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    // 实例化与使用

    // 显式实例化：编译器根据你传入的类型生成特定版本的函数
    int max_int = maximum(5, 10); // 实例化出 maximum(int, int)
    std::cout << "Max int: " << max_int << std::endl; // Output: Max int: 10

    double max_double = maximum(3.14, 2.71); // 实例化出 maximum(double, double)
    std::cout << "Max double: " << max_double << std::endl; // Output: Max double: 3.14

    std::string s1 = "world", s2 = "hello";
    std::string max_string = maximum(s1, s2); // 实例化出 maximum(string, string)
    std::cout << "Max string: " << max_string << std::endl; // Output: Max string: world

    // 隐式实例化：编译器根据函数参数的类型自动推导
    // 这在大多数情况下更常见，也更方便
    int another_max_int = maximum(7, 2); // 编译器自动推导出 T 为 int
    std::cout << "Another max int: " << another_max_int << std::endl; // Output: Another max int: 7

    double another_max_double = maximum(1.23, 4.56); // 编译器自动推导出 T 为 double
    std::cout << "Another max double: " << another_max_double << std::endl; // Output: Another max double: 4.56

    // 注意：如果类型不匹配，或者编译器无法推导，就得显式指定
    // maximum(1, 2.5); // 这会报错，因为 T 无法同时是 int 和 double
    // 此时你需要：
    double mixed_max = maximum(1, 2.5); // 显式指定 T 为 double，1 会被隐式转换为 double
    std::cout << "Mixed max: " << mixed_max << std::endl; // Output: Mixed max: 2.5

    return 0;
}

函数模板的声明就是定义那个 template 部分，然后跟着正常的函数签名。实例化嘛，就是你真正调用这个函数的时候，编译器根据你提供的信息（显式指定或隐式推导）来生成一个特定类型的函数版本。这个过程是发生在编译期的。

类模板的声明与实例化： 类模板的道理也差不多，只不过它作用于整个类。当你需要一个容器，比如一个链表或者一个栈，它需要存储各种不同类型的数据时，类模板就非常有用了。

#include 
#include 

// 声明一个类模板
template
class MyContainer {
private:
    T value;
public:
    MyContainer(T val) : value(val) {}
    void print() {
        std::cout << "Value: " << value << std::endl;
    }
    T getValue() const {
        return value;
    }
};

int main() {
    // 实例化与使用
    // 类模板的实例化必须是显式的，编译器无法自动推导类的类型参数
    MyContainer int_container(100); // 实例化出 MyContainer
    int_container.print(); // Output: Value: 100

    MyContainer string_container("Hello Templates"); // 实例化出 MyContainer
    string_container.print(); // Output: Value: Hello Templates

    // 错误示范：类模板无法隐式实例化
    // MyContainer mc(5); // 编译错误！必须指定类型参数

    return 0;
}

类模板的声明也是在 class 或 struct 关键字前加上 template。实例化则是在使用类名时，在尖括号 <> 中指定具体的类型。这和函数模板的隐式实例化有本质区别，类模板的类型参数必须显式提供。这背后其实是设计哲学上的差异：函数调用时参数是已知的，编译器可以据此推断；而类声明一个对象时，其内部类型是什么，只有开发者知道，所以必须明确告知。

初学模板，很多人可能会觉得有点绕，特别是 typename 和 class 的区别。其实在模板参数列表中，它们大多数时候是等价的，都表示一个类型参数。但 typename 还有另一个更重要的用途，在模板内部，如果某个依赖于模板参数的名字可能是一个类型，你需要用 typename 来明确告诉编译器它是一个类型。这在一些复杂模板元编程或者嵌套类型访问时会遇到。比如 typename Container::iterator。

还有一点，模板代码通常写在头文件中。这是因为模板的实例化发生在编译期，编译器需要看到模板的完整定义才能生成特定版本的代码。如果把实现放在 .cpp 文件里，链接器会找不到对应的实例化代码，导致链接错误。这是一个很常见的“坑”。

C++模板究竟解决了哪些实际编程痛点？

模板的核心价值在于“泛型编程”。想象一下，你需要一个通用的排序算法，它可以对整数数组排序，也能对浮点数数组排序，甚至可以对自定义对象数组（只要它们支持比较操作）排序。如果没有模板，你可能要为每种数据类型写一个几乎一模一样的排序函数，这不仅代码冗余，难以维护，而且一旦算法有更新，你需要修改所有版本。模板通过将类型抽象化，让你只需编写一份代码，就能适用于多种数据类型，极大地提高了代码的复用性和可维护性。

再比如，标准库中的 std::vector、std::list、std::map 这些容器，它们能够存储任何类型的数据，这正是因为它们都是类模板。std::vector 和 std::vector 用的都是同一份 vector 的蓝图，只是实例化时传入了不同的类型参数。这省去了开发者为每种数据类型重新实现一套容器的麻烦。

它还促进了代码的抽象和模块化。你可以专注于算法或数据结构的逻辑，而不用过早地绑定到具体的类型上。这使得库的开发变得更加灵活和强大。

函数模板与类模板在设计理念和使用场景上有何异同？

它们都是C++泛型编程的基石，目的都是为了实现代码复用和类型参数化。

相同点：

• 泛型化能力： 都允许用类型参数（typename 或 class）来替代具体的数据类型，从而编写出不依赖于特定类型的通用代码。
• 编译期实例化： 模板的实例化过程都发生在编译期。编译器会根据使用情况，为每个具体的类型参数生成一份专属的代码。
• 减少代码重复： 这是最显著的共同优点，避免了为不同数据类型编写重复的逻辑或结构。

不同点：

• 作用对象： 函数模板作用于独立的函数，使得函数能够处理不同类型的数据。类模板作用于整个类，使得类（及其成员）能够操作不同类型的数据。
• 实例化方式：
  • 函数模板： 既支持显式实例化（function(args)），也支持隐式实例化（function(args)，编译器根据参数推导类型）。