第六弹：深入理解 C++ 模板机制及其应用

三玖诶

于 2024-10-06 10:07:38 发布

阅读量814

点赞数 19

分类专栏： C++ 文章标签： c++ 函数模板类模板

本文链接：https://blog.csdn.net/weixin_65477256/article/details/142723717

版权

C++ 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

深入理解 C++ 模板机制及其应用

C++ 模板是实现泛型编程的重要工具，提供了代码复用、类型安全和编译期多态的能力。模板不仅让程序适应任意数据类型，还能够通过类和函数的参数化，使得编译器在编译阶段自动生成代码，减少开发过程中的重复工作。本文将详细探讨模板的各个知识点，展示如何通过模板机制编写高效、灵活的代码。

1. 模板概述

模板是一种参数化机制，允许开发者编写与具体类型无关的通用代码。C++ 模板主要有两种类型：函数模板和类模板。

函数模板：用于创建可以处理多种类型参数的通用函数。
类模板：用于定义数据结构和成员函数可以处理多种类型的通用类。

模板允许开发者编写逻辑结构相同但数据类型不同的代码，极大地提升了代码的复用性和可扩展性。

2. 函数模板

2.1 函数模板的定义

函数模板是为多个不同数据类型的函数创建的通用形式。通过 template <typename T>（或 template <class T>）关键字，开发者可以定义一个接受不同类型参数的通用函数。例如：

// 函数模板的定义，T 是模板参数，可以代表任意类型
template <typename T>
T add(T a, T b) {
    return a + b;
}

该模板函数可以接受 int、double 甚至 string 等不同类型的参数，编译器会根据传入参数的类型生成适当的函数版本。

2.2 函数模板的调用

调用模板函数与普通函数类似。编译器会根据传入参数的类型实例化模板，并生成相应的函数。代码如下：

int main() {
    cout << add(1, 5) << endl;            // 调用 int 类型的模板函数
    cout << add(1.2, 2.3) << endl;        // 调用 double 类型的模板函数
    cout << add(string("Hello"), string(" World")) << endl;  // 调用 string 类型的模板函数
}

模板函数的调用规则：

若存在与模板函数同名的普通函数且匹配，优先调用普通函数。
若没有匹配的普通函数，编译器会实例化并调用模板函数。
若需要强制调用模板函数，可使用 add<int>(1, 2) 这样的显示模板实例化语法。

2.3 函数模板与普通函数的区别

模板函数不允许自动类型转换：函数模板要求参数的类型完全匹配，不能进行隐式类型转换。
普通函数允许自动类型转换：普通函数在传递参数时可以自动执行类型转换。

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

int my_add(int a, int b) {
    return a + b;
}

int main() {
    int x = 3;
    char c = 'a';
    cout << my_add(x, c) << endl;  // 普通函数允许自动类型转换
    // cout << myAdd(x, c) << endl; // 错误：模板函数不允许自动类型转换
}

2.4 类型模板参数与非类型模板参数

模板除了可以接受类型参数外，还可以接受非类型参数。非类型模板参数的作用是在模板中传递一些固定的值，如数组的大小等。如下例所示，nmemb 是一个非类型模板参数：

// nmemb 是非类型模板参数，表示数组的大小
template <typename T, int nmemb>
void print_arr(T a[]) {
    for (int i = 0; i < nmemb; i++)
        cout << a[i] << " ";
    cout << endl;
}

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    print_arr<int, 5>(arr);  // 打印数组
}

3. 类模板

3.1 类模板的定义

类模板类似于函数模板，允许创建可以操作不同类型数据的类。通过 template <typename T>，开发者可以定义通用类，允许在类的不同实例中使用不同的数据类型。例如：

template <typename T>
class Arr {
public:
    Arr(int size = 0) {
        this->p = new T[size];
        this->size = size;
    }

    ~Arr() {
        delete[] p;
    }

    void show() {
        for (int i = 0; i < size; i++)
            cout << p[i] << " ";
        cout << endl;
    }

private:
    T* p;  // T 是模板参数，具体的类型会在类实例化时确定
    int size;
};

int main() {
    Arr<int> arrInt(5);     // 创建处理 int 类型的数组
    arrInt.show();
    Arr<double> arrDouble(5);  // 创建处理 double 类型的数组
    arrDouble.show();
}

3.2 类型模板参数与非类型模板参数

类模板中，类型模板参数和非类型模板参数都可以设置默认值。通过这种方式，类模板的使用更加灵活。

template <typename T = int, int size = 5>
class ARR {
public:
    ARR() {
        this->p = new T[size];
    }
    ~ARR() {
        delete[] p;
    }
    void show() {
        for (int i = 0; i < size; i++)
            cout << p[i] << " ";
        cout << endl;
    }

private:
    T* p;
};

int main() {
    ARR<> arr;  // 使用默认类型 int 和默认大小 5
    arr.show();
}

3.3 类模板作为函数参数

类模板可以作为函数的形参传递，方便函数处理不同类型的类模板实例。例如：

template <typename T1, typename T2>
class Demo {
public:
    Demo(T1 name, T2 val) : name(name), val(val) {}
    T1 name;
    T2 val;
};

template <typename T1, typename T2>
void PrintDemo(const Demo<T1, T2>& obj) {
    cout << "Name: " << obj.name << ", Value: " << obj.val << endl;
}

int main() {
    Demo<string, int> demo("Alice", 25);
    PrintDemo(demo);  // 打印 demo 对象的内容
}

3.4 类模板作为派生类的基类

类模板可以作为基类，而派生类既可以是普通类，也可以是类模板。示例如下：

// 普通类作为派生类
class Demo : public Base<int> {
public:
    Demo(int val) : Base(val) {}
};

// 类模板作为派生类
template <typename T>
class Demo : public Base<T> {
public:
    Demo(T val) : Base<T>(val) {}
};

3.5 类模板的实现

类模板的成员函数可以定义在类内部或类外部。在类外部定义时，需要加上模板声明。

// 类模板声明
template <typename T>
class Demo {
public:
    void setVal(T myVal);
    T getVal();
private:
    T val;
};

// 类模板成员函数定义
template <typename T>
void Demo<T>::setVal(T myVal) {
    val = myVal;
}

template <typename T>
T Demo<T>::getVal() {
    return val;
}

int main() {
    Demo<int> obj;
    obj.setVal(100);
    cout << obj.getVal() << endl;
}

4. 函数模板作为类模板的友元

函数模板可以作为类模板的友元，允许它们访问类的私有成员。友元函数模板的声明与类模板的声明类似，但两者的符号不能混淆。示例如下：

template <typename T>
class Demo {
private:
    T val;
    template <typename C>
    friend void setVal(Demo<C>& obj, C val);
    template <typename C>
    friend C getVal(const Demo<C>& obj);
};

// 定义友元函数模板
template <typename T>
void setVal(Demo<T>& obj, T val) {
    obj.val = val;
}

template <typename T>
T getVal(const Demo<T>& obj) {
    return obj.val;
}

int main() {
    Demo<int> obj;
    setVal(obj, 123);
    cout << getVal(obj) << endl;
}

5. 模板的特化

5.1 全特化

模板特化是为特定类型提供专门的实现。在全特化中，模板只处理某个特定类型的数据，忽略其他类型。

// 通用模板
template <typename T>
class

 Demo {
public:
    void show() {
        cout << "Generic Template" << endl;
    }
};

// 针对 int 类型的特化
template <>
class Demo<int> {
public:
    void show() {
        cout << "Specialized Template for int" << endl;
    }
};

int main() {
    Demo<double> d1;
    d1.show(); // 通用模板
    Demo<int> d2;
    d2.show(); // int 类型的特化版本
}

5.2 偏特化

偏特化允许部分模板参数进行特化。例如，针对部分类型参数提供特殊化实现。

template <typename T1, typename T2>
class Demo {
public:
    void show() {
        cout << "Generic Template" << endl;
    }
};

// 偏特化，第二个模板参数固定为 int
template <typename T1>
class Demo<T1, int> {
public:
    void show() {
        cout << "Specialized Template for <T1, int>" << endl;
    }
};

int main() {
    Demo<double, double> d1;
    d1.show(); // 通用模板
    Demo<double, int> d2;
    d2.show(); // 偏特化版本
}

6. 可变参数模板（Variadic Templates）

C++11 引入了可变参数模板，允许定义能够接受任意数量参数的模板。这极大地增强了模板的灵活性。

6.1 可变参数函数模板

可变参数函数模板可以接受任意数量的参数，并通过递归展开的方式处理参数。例如：

template<typename T>
void print(T arg) {
    cout << arg << endl;
}

template<typename T, typename... Args>
void print(T firstArg, Args... args) {
    cout << firstArg << " ";
    print(args...);  // 递归调用
}

int main() {
    print(1, 2.5, "Hello", 'A');  // 可以接受多个参数
}

6.2 可变参数类模板

类模板也可以通过可变参数处理不同数量的类型参数：

template<typename... Values>
class Tuple {
    // 可以存储任意类型的多个参数
};

int main() {
    Tuple<int, double, string> t;  // 存储不同类型的参数
}

7. 模板的默认参数

模板参数可以设定默认值，从而减少实例化时的参数指定。如下：

template <typename T = int, int size = 10>
class Array {
public:
    Array() {
        data = new T[size];
    }
    ~Array() {
        delete[] data;
    }
private:
    T* data;
};

int main() {
    Array<> arr;  // 使用默认类型 int 和大小 10
}

8. SFINAE（Substitution Failure Is Not An Error）

SFINAE 是模板编程中的一种重要机制，它允许在模板类型替换失败时选择其他模板，而不导致编译错误。这使得可以通过类型特性限制模板实例化的条件。

使用 `std::enable_if` 进行类型限制

#include <type_traits>

template<typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
add(T a, T b) {
    return a + b;
}

int main() {
    cout << add(1, 2) << endl;  // 正常工作，1 和 2 是整数
    // cout << add(1.1, 2.2) << endl;  // 编译错误，因为浮点数不满足 is_integral 条件
}

9. 模板元编程（Template Metaprogramming）

模板元编程通过递归和编译期求值，允许在编译期执行复杂计算。如下例，通过模板递归计算阶乘：

template<int N>
struct Factorial {
    static const int value = N * Factorial<N - 1>::value;
};

template<>
struct Factorial<0> {
    static const int value = 1;
};

int main() {
    cout << "Factorial of 5: " << Factorial<5>::value << endl;  // 输出 120
}

10. 类型萃取（Type Traits）

C++ 标准库提供了 type_traits，用于检测类型特性。它可以帮助开发者在模板中进行类型推断或限制。例如：

#include <type_traits>

template<typename T>
void checkType() {
    if (std::is_integral<T>::value)
        cout << "T is an integral type" << endl;
    else
        cout << "T is not an integral type" << endl;
}

int main() {
    checkType<int>();     // 输出: T is an integral type
    checkType<double>();  // 输出: T is not an integral type
}

总结

本文系统地介绍了 C++ 模板的方方面面，包括函数模板、类模板、模板特化、可变参数模板、SFINAE 机制、模板元编程以及类型萃取等高级特性。C++ 的模板机制通过编译期的类型推导和代码生成，极大地增强了代码的灵活性和可重用性。掌握这些技术，能够帮助开发者编写出更加高效和安全的泛型代码，在实际开发中提升程序性能和可维护性。