C++模板

函数模板

函数模板是C++中实现泛型编程的重要工具。它允许你定义一个通用的函数，该函数可以适用于不同类型的数据。在定义函数模板时，可以使用类型参数，编译器在实际调用时根据传入的参数类型自动生成具体的函数实现。

1. 函数模板的定义与使用

1.1 基本语法

函数模板的定义与普通函数类似，只是需要在函数名前面添加模板参数列表。模板参数列表通常使用template <typename T>或template <class T>来表示，其中T是类型参数。

示例

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

在这个例子中，add函数被定义为一个模板函数，可以接受任意类型T的参数。

1.2 函数模板的调用

当你调用一个函数模板时，编译器会根据传入的参数类型自动推导模板参数的类型。

int x = 5, y = 10;
double a = 2.5, b = 3.5;

std::cout << add(x, y) << std::endl;   // T 被推导为 int
std::cout << add(a, b) << std::endl;   // T 被推导为 double

1.3 显式指定模板参数

在某些情况下，你可能希望显式指定模板参数类型，而不是依赖编译器自动推导。这可以通过在函数名后面使用尖括号<>指定类型参数来实现。

std::cout << add<int>(3, 4) << std::endl;   // 显式指定 T 为 int

2. 多个模板参数

函数模板可以接受多个模板参数，这些参数可以是相同或不同的类型。

示例

template <typename T1, typename T2>
auto multiply(T1 a, T2 b) -> decltype(a * b) {
    return a * b;
}

这里使用了两个模板参数T1和T2，函数返回值类型通过decltype推导。

int x = 5;
double y = 10.5;

std::cout << multiply(x, y) << std::endl;   // T1 被推导为 int，T2 被推导为 double

3. 函数模板的特化

函数模板特化允许为特定的类型提供特殊的实现。特化可以是完全特化（所有模板参数都固定）或部分特化（部分模板参数固定）。

3.1 完全特化

完全特化是指针对某个具体类型提供专门的函数实现。

示例

template <>
const char* add(const char* a, const char* b) {
    // 实现字符串连接
    static std::string result = std::string(a) + std::string(b);
    return result.c_str();
}

这个示例中，针对const char*类型特化了add函数模板。

3.2 函数模板的重载

与普通函数一样，函数模板也可以被重载。重载时，模板参数数量、类型或顺序可以不同。

示例

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

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

int main() {
    std::cout << add(1, 2) << std::endl;       // 调用两个参数的 add
    std::cout << add(1, 2, 3) << std::endl;    // 调用三个参数的 add
    return 0;
}

4. 函数模板的局限性和注意事项

4.1 编译器推导的限制

编译器在推导模板参数时有时会遇到困难，尤其是在复杂的表达式或类型转换的情况下。这可能导致需要显式指定模板参数。

4.2 返回类型的推导

在某些情况下，返回类型无法通过模板参数直接推导出来，需要使用decltype或auto关键字来推导返回类型。

template <typename T1, typename T2>
auto add(T1 a, T2 b) -> decltype(a + b) {
    return a + b;
}

4.3 模板实例化

函数模板在编译时根据实际使用的参数类型生成具体的函数，这意味着每种类型的使用都会生成一个新的函数实例。如果模板的使用过多，可能会导致代码膨胀（编译后的代码体积增大）。

4.4 链接错误

如果函数模板的定义和声明分离，可能会导致链接错误。通常建议将函数模板的定义和实现放在同一个头文件中，以避免这些问题。

5. 函数模板与普通函数的区别

• 类型安全性：函数模板提供了类型安全性，可以在编译时检测类型错误，而宏或其他方式无法提供这样的安全性。
• 代码复用性：函数模板允许编写更加通用的代码，减少代码重复。
• 性能：由于模板是在编译时实例化的，不会引入运行时开销，性能与手写的类型特定函数相当。

6. 高级函数模板特性

6.1 SFINAE（Substitution Failure Is Not An Error）

SFINAE（Substitution Failure Is Not An Error，即替换失败不是错误）是 C++ 中的一个概念，它描述了模板参数替换过程中的一种行为。当一个模板参数被替换为另一个类型时，如果替换后的表达式与原始表达式在语义上不同，编译器将不会报错，而是允许编译过程继续。

SFINAE 通常与模板重载（模板的函数重载）一起使用，以提供一种更加灵活的方式来处理模板函数的参数。

示例

template<typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
foo(T t) {
    return t + 1;  // 仅当 T 为整数类型时，该模板才有效
}

这段代码是一个 C++ 模板函数的定义，它使用了 SFINAE（Substitution Failure Is Not An Error，即替换失败不是错误）技巧和 std::enable_if 条件类型模板。下面是这段代码的解释：

1. 模板参数： template<typename T> 表明这是一个模板函数，它的参数类型是 T。
2. 条件类型模板： typename std::enable_if<std::is_integral<T>::value, T>::type 是一个条件类型模板，它由两部分组成：
   • std::is_integral<T>::value：这是一个类型谓词，用于检查 T 是否是一个整数类型。
   • typename std::enable_if<condition, type>::type：这是一个条件类型模板，用于根据条件来决定返回的类型。
3. 条件： std::is_integral<T>::value 是一个类型谓词，它返回一个布尔值，指示 T 是否是一个整数类型。
4. 返回类型： 如果 T 是一个整数类型，那么 typename std::enable_if<std::is_integral<T>::value, T>::type 将返回 T 类型的对象。如果 T 不是一个整数类型，这个条件类型模板将不会被实例化，因此不会影响函数的返回类型。
5. 函数体： 函数体 return t + 1; 计算 t 的值并加一。由于我们使用了条件类型模板，这个操作只有在 T 是一个整数类型时才会执行。

6.2 可变参数模板

可变参数模板允许定义接受任意数量参数的模板，这在编写泛型代码时非常有用。

6.2.1 基本语法

可变参模板的定义通常包括一个或多个普通模板参数，后跟一个模板参数包。模板参数包使用typename...或class...表示。

template <typename... Args>
void print(Args... args) {
    // 实现代码
}

在函数参数中，同样可以使用参数包来表示任意数量的函数参数。

template <typename... Args>
void print(Args... args) {
    // 实现代码
}

6.2.2 展开参数包

参数包不能直接使用，必须展开或处理。展开参数包是指将参数包分解成具体的参数列表，并在相应的上下文中处理这些参数。通常有两种展开方式：

• 递归展开：通过递归函数调用逐步处理参数包中的每个参数。
• 折叠表达式：使用C++17引入的折叠表达式，可以简化参数包的处理。

6.2.2.1 递归展开

递归展开是处理参数包的传统方法，通常通过基函数（处理单个参数）和递归函数（处理多个参数）来实现。

// 基函数：处理单个参数的函数模板
void print() {
    std::cout << std::endl;
}

// 递归函数：逐个处理参数包中的每个参数
template <typename T, typename... Args>
void print(T first, Args... args) {
    std::cout << first << " ";
    print(args...);  // 递归调用
}

int main() {
    print(1, 2.5, "Hello", 'c');  // 输出: 1 2.5 Hello c
    return 0;
}

在这个例子中，print函数模板处理第一个参数first后，递归调用自身以处理剩余的参数args...。当参数包为空时，基函数print()被调用，递归结束。

6.2.2.2 折叠表达式

C++17引入了折叠表达式，使得参数包的展开和处理更加简洁。折叠表达式是一种特殊的表达式，用于将参数包中的所有参数通过指定的运算符进行组合。

示例

template <typename... Args>
void print(Args... args) {
    (std::cout << ... << args) << std::endl;  // 使用左折叠展开参数包
}

int main() {
    print(1, 2.5, "Hello", 'c');  // 输出: 1 2.5 Hello c
    return 0;
}

在这个例子中，(std::cout << ... << args) 是一个左折叠表达式，它将所有参数依次输出到标准输出流。

折叠表达式的常见类型包括：

• 左折叠：( op ... op args )，例如(args + ...)。
• 右折叠：( args op ... op )，例如(... + args)。
• 带初始值的折叠：( init op ... op args )，例如(0 + ... + args)。

6.2.3 可变参模板的常见应用

可变参模板在泛型编程中有广泛的应用。以下是一些常见的应用场景：

6.2.3.1 打印任意数量的参数

使用递归展开或折叠表达式，可以实现打印任意数量参数的函数。

template <typename... Args>
void print(Args... args) {
    (std::cout << ... << args) << std::endl;
}

6.2.3.2 实现通用的构造函数

可变参模板常用于类模板的构造函数中，使得类可以接受任意数量的构造参数。

template <typename... Args>
class MyClass {
public:
    MyClass(Args... args) {
        // 处理构造参数
    }
};

6.2.3.3 实现通用的容器

可变参模板可以用于实现通用的容器，如std::tuple，它可以存储任意数量和类型的元素。

template <typename... Types>
class Tuple {
    // 实现代码
};

6.2.3.4 元编程

可变参模板在元编程中非常有用，可以用于编写复杂的编译期计算。

6.2.4. 注意事项

• 编译时间：可变参模板的展开和实例化可能会导致编译时间增加，尤其是在参数数量很多的情况下。
• 错误信息复杂：由于参数包展开涉及递归或折叠，编译错误信息可能会比较复杂，难以调试。
• 递归深度：在递归展开时，需要注意递归深度过大可能导致编译器栈溢出。

7. 函数模板的常见应用场景

• 通用算法：如排序、查找、计算等算法，可以使用模板来处理不同类型的数据。
• 容器类的实现：如STL中的vector, list等容器，都是通过模板来实现以适应不同的数据类型。
• 数学运算：如加法、乘法、最大值最小值计算等，使用模板可以避免为不同类型重复编写函数。

8. 总结

函数模板是C++泛型编程的核心，允许编写类型无关的通用代码。通过模板，可以实现高效、灵活、类型安全的代码。理解函数模板的工作原理及其局限性，能帮助你更好地利用这一强大工具编写高质量的C++程序。

类模板

类模板是C++中用于定义泛型类的工具。类模板允许你创建可以处理不同数据类型的类，而无需为每种类型重复编写相同的代码。

1. 类模板的定义与使用

1.1 基本语法

类模板的定义类似于函数模板，只是模板参数应用于整个类。你可以使用template <typename T>或template <class T>来定义一个类模板。

示例

template <typename T>
class Box {
private:
    T value;
public:
    Box(T val) : value(val) {}
    T getValue() const { return value; }
    void setValue(T val) { value = val; }
};

在这个例子中，Box类模板被定义为能够存储和操作任意类型T的值。

1.2 类模板的实例化

在使用类模板时，需要指定具体的类型参数来实例化模板。例如：

Box<int> intBox(123);      // T 被推导为 int
Box<double> doubleBox(45.67);  // T 被推导为 double

std::cout << intBox.getValue() << std::endl;
std::cout << doubleBox.getValue() << std::endl;

1.3 模板参数的默认值

类模板的模板参数可以有默认值，这使得在实例化时可以省略某些参数。

template <typename T = int>
class Box {
    // 类定义
};

Box<> defaultBox;  // T 默认推导为 int

2. 类模板的成员函数定义

2.1 类内定义

类模板的成员函数可以直接在类内定义，这与普通类的成员函数定义方式相同。

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

2.2 类外定义

你也可以在类外定义类模板的成员函数。这时，函数定义需要明确指出它属于哪个模板类，并且必须在函数名前加上模板参数列表。

template <typename T>
T Box<T>::getValue() const {
    return value;
}

3. 类模板的特化

类模板特化允许为特定类型提供特殊的实现。特化可以是完全特化（所有模板参数都固定）或部分特化（部分模板参数固定）。

3.1 完全特化

完全特化是指针对某个具体类型提供专门的类实现。

示例

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

在这个示例中，我们为char类型完全特化了Box类。

3.2 部分特化

部分特化允许为部分模板参数固定的情况下提供特化的实现。

示例

template <typename T>
class Box<T*> {  // 对指针类型进行部分特化
private:
    T* value;
public:
    Box(T* val) : value(val) {}
    T* getValue() const { return value; }
};

在这个例子中，我们对指针类型的Box类进行了部分特化。

4. 模板的嵌套和模板友元

4.1 嵌套类模板

类模板可以包含另一个类模板作为嵌套类型。这在设计复杂的数据结构时非常有用。

示例

template <typename T>
class Outer {
public:
    template <typename U>
    class Inner {
        U innerValue;
    public:
        Inner(U val) : innerValue(val) {}
        U getValue() const { return innerValue; }
    };
};

4.2 模板友元

类模板可以指定模板友元，友元可以是函数模板、类模板或普通函数和类。

示例

template <typename T>
class Box {
    T value;
    friend void showValue(Box<T>& box);
};

template <typename T>
void showValue(Box<T>& box) {
    std::cout << box.value << std::endl;
}

5. 类模板与继承

5.1 类模板的继承

类模板可以作为基类被继承，派生类可以是普通类、模板类或其他类的实例化。

示例

template <typename T>
class Base {
protected:
    T value;
public:
    Base(T val) : value(val) {}
};

template <typename T>
class Derived : public Base<T> {
public:
    Derived(T val) : Base<T>(val) {}
    T getValue() const { return this->value; }
};

5.2 派生类模板与基类模板的访问

派生类模板中的基类成员访问需要明确模板参数，特别是在使用模板成员时。

template <typename T>
class Derived : public Base<T> {
public:
    Derived(T val) : Base<T>(val) {}
    void show() {
        std::cout << Base<T>::value << std::endl;  // 需要使用 Base<T>:: 来访问基类成员
    }
};

6. 类模板的使用注意事项

6.1 编译时间与代码膨胀

类模板在编译时会根据实际使用的类型生成具体的类。这可能会导致编译时间增加和生成代码体积膨胀，尤其是大量使用模板时。

6.2 链接问题

类模板的定义和实现通常放在同一个头文件中，以避免链接错误。由于模板是在编译时实例化的，如果分离定义和实现可能会导致链接器无法找到模板的具体实现。

6.3 模板的错误信息

由于模板代码的泛型特性，编译时的错误信息可能会非常复杂且难以理解。理解这些错误信息需要深入理解模板机制。

7. 类模板的应用场景

• 泛型容器：如STL中的vector、list等容器，都是通过类模板来实现，以支持不同类型的数据。
• 数据结构：如栈、队列、树等数据结构，可以使用类模板来实现以适应不同的数据类型。
• 算法类：可以通过类模板实现通用的算法类，如排序、搜索等，适用于不同的数据类型。

8. 总结

类模板是C++中实现泛型编程的关键工具。它允许我们创建可以处理多种数据类型的类，从而提高代码的复用性和灵活性。掌握类模板的定义、使用、特化、嵌套与继承等知识点，可以帮助你编写出高效且通用的C++程序。