C++——模板的奥秘

函数模板

函数模板（Template function）是C++中一种强大的特性，允许编写通用的函数代码，能够处理多种数据类型而不需要重复编写多个函数。下面是关于函数模板的语法结构、定义、示例和注意事项的详细介绍。

语法结构

函数模板的基本语法结构如下：

template <typename T>
T functionName(T parameter1, T parameter2, ...) {
    // 函数体
}

或者可以使用 class 关键字代替 typename：

template <class T>
T functionName(T parameter1, T parameter2, ...) {
    // 函数体
}

定义

template 或 template ：声明一个模板，T 是类型参数，可以是任何合法的类型，包括内置类型（如 int, double）或自定义类类型。

T functionName(T parameter1, T parameter2, …)：定义一个模板函数，参数和返回类型都是类型参数 T。函数体内的操作可以使用类型参数 T 定义的任何操作。

示例

示例 1：模板函数求最大值

#include <iostream>

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

int main() {
    std::cout << maxValue(5, 10) << std::endl;        // 输出：10
    std::cout << maxValue(3.5, 1.2) << std::endl;    // 输出：3.5
    return 0;
}

在这个例子中，maxValue 函数模板可以处理 int 和 double 类型的参数，返回相应类型的最大值。

示例 2：模板函数交换值

#include <iostream>

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

int main() {
    int x = 5, y = 10;
    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;
    swapValues(x, y);
    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;

    double a = 3.5, b = 1.2;
    std::cout << "Before swap: a = " << a << ", b = " << b << std::endl;
    swapValues(a, b);
    std::cout << "After swap: a = " << a << ", b = " << b << std::endl;

    return 0;
}

这个示例展示了模板函数 swapValues 可以交换任意类型的值，包括 int 和 double。

注意事项

模板参数类型推导：通常情况下，编译器能够从函数参数推导出模板参数类型，但在某些情况下可能需要显式指定类型。

模板特化和偏特化：可以为模板定义特定类型的特化版本或部分特化版本，以处理特定类型的操作或优化实现。

编译器支持：不同的编译器对C++模板的支持程度不同，有些旧版本的编译器可能存在限制或bug。

模板函数的代码重用：函数模板允许代码重用，避免了为不同类型写多个函数的重复劳动，提高了代码的可维护性和灵活性。

类模板

类模板（Class Template）是C++中用于创建通用类的工具，允许定义一种类的蓝图，以便处理多种数据类型而无需为每种类型编写不同的类定义。以下是关于类模板的语法结构、定义、示例和注意事项的详细解释：

语法结构

类模板的基本语法结构如下：

template <typename T>
class ClassName {
public:
    // 成员变量和成员函数的定义，可以使用类型参数 T
};

或者可以使用 class 关键字代替 typename：

template <class T>
class ClassName {
public:
    // 成员变量和成员函数的定义，可以使用类型参数 T
};

定义

template 或 template ：声明一个模板，T 是类型参数，可以是任何合法的类型，包括内置类型（如 int, double）或自定义类类型。

class ClassName：定义一个模板类，类名后跟模板参数 （或 ），以表示这是一个模板类。

在类模板中可以定义成员变量、成员函数和构造函数，这些都可以使用模板参数 T。

示例

示例 1：类模板实现堆栈（Stack）

#include <iostream>
#include <vector>

template <typename T>
class Stack {
private:
    std::vector<T> elements;

public:
    void push(const T& element) {
        elements.push_back(element);
    }

    void pop() {
        if (!elements.empty()) {
            elements.pop_back();
        }
    }

    T top() const {
        if (!elements.empty()) {
            return elements.back();
        }
        throw std::out_of_range("Stack<>::top(): empty stack");
    }

    bool empty() const {
        return elements.empty();
    }
};

int main() {
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    intStack.push(3);

    while (!intStack.empty()) {
        std::cout << intStack.top() << " ";
        intStack.pop();
    }
    std::cout << std::endl;

    Stack<std::string> stringStack;
    stringStack.push("Hello");
    stringStack.push("World");

    while (!stringStack.empty()) {
        std::cout << stringStack.top() << " ";
        stringStack.pop();
    }
    std::cout << std::endl;

    return 0;
}

在这个示例中，Stack 类模板定义了一个通用的堆栈数据结构，可以处理任意类型的数据，包括 int 和 std::string。

注意事项

模板参数类型推导：类模板可以根据使用时传递的参数推导出类型，但有时可能需要显式指定类型。

成员函数定义：类模板的成员函数可以在类外定义，也可以在类内定义，但通常推荐将较复杂的函数定义放在类外。

模板特化和偏特化：类模板可以像函数模板一样进行特化和偏特化，以处理特定类型或特定情况下的优化。

编译器支持：不同的编译器对类模板的支持程度可能有所不同，需要注意兼容性和遵循C++标准。

模板实例化：在使用类模板时，编译器会根据具体的模板参数生成相应的类实例（实例化过程），并处理类模板中的每个成员。.

常见错误

当使用类模板时，常见的容易犯的错误包括以下几种：

忘记模板参数列表：

template <typename T>
class MyClass {
    // 类定义
};

// 错误示例：忘记模板参数列表 <>
MyClass obj;  // 编译器会报错，需要指定模板参数 MyClass<T>

模板成员函数的实现位置错误：

template <typename T>
class MyClass {
public:
    // 正确的成员函数实现位置
    void memberFunction() {
        // 函数定义
    }
};

// 错误示例：将成员函数定义放在类外
template <typename T>
void MyClass<T>::memberFunction() {
    // 错误的位置，应在类内实现
}

未提供模板参数或提供错误的模板参数：

template <typename T>
class MyClass {
    // 类定义
};

// 错误示例：提供了错误的模板参数类型
MyClass<int> obj;  // MyClass 需要一个类型参数 T，不是 int

模板类的友元函数定义：

template <typename T>
class MyClass {
    template <typename U>
    friend void friendFunction(MyClass<U>& obj);  // 友元函数的正确定义方式
};

// 错误示例：未正确定义友元函数
template <typename T>
friend void friendFunction(MyClass<T>& obj);  // 错误的定义方式

访问模板类的私有成员：

template <typename T>
class MyClass {
private:
    int privateMember;

public:
    void setPrivateMember(int value) {
        privateMember = value;
    }
};

int main() {
    MyClass<int> obj;
    obj.setPrivateMember(5);

    // 错误示例：不能直接访问私有成员 privateMember
    // int value = obj.privateMember;  // 编译器会报错，privateMember 是私有的
    return 0;
}

未处理模板类中的异常情况：

template <typename T>
class MyClass {
private:
    T data;

public:
    MyClass() {
        // 构造函数可能需要处理异常
    }

    T getData() {
        // 函数可能会抛出异常
    }
};

使用模板类时忘记包含模板头文件：

// 错误示例：未包含模板类的头文件
#include "MyClass.h"

int main() {
    MyClass<int> obj;  // 编译器无法找到 MyClass 类的定义，会报错
    return 0;
}