C++ 泛型编程指南之函数模板

最新推荐文章于 2024-10-12 22:47:18 发布
最新推荐文章于 2024-10-12 22:47:18 发布
阅读量1.2k 收藏 17
点赞数 19
文章标签： c++ 开发语言 算法 泛型编程 模板 两阶段编译 宏函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55125921/article/details/141093967
版权

欢迎大家来到我们的 C++ 泛型（模板）编程分享。

文章目录

为什么我们需要模板

在C++中，模板是一种强大的机制，它允许你编写泛型代码，即可以处理多种数据类型的代码。通过使用模板，你可以编写灵活且可重用的函数和类，而不需要为每种数据类型都重复相同的逻辑。

在学习模板之前，如果你要比较多种类型变量的大小，你可能要写出这样的代码

#include <iostream>
#include <string>

using std::string;
using std::cout;
using std::endl;

// 交换两个 int 型变量的值
void Swap(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

// 交换两个 double 型变量的值
void Swap(double& a, double& b) {
    double tmp = a;
    a = b;
    b = tmp;
}

// 交换两个 string 型变量的值
void Swap(string& a, string& b) {
    string tmp = a;
    a = b;
    b = tmp;
}

int main() {
    int a = 1, b = 2;
    double da = 1.0, db = 2.0;
    string sa = "sa", sb = "sb"; // 注意这里变量名由sc改为sb，以匹配Swap函数的调用

    cout << "Before swapping ints: a = " << a << ", b = " << b << endl;
    Swap(a, b);
    cout << "After swapping ints: a = " << a << ", b = " << b << endl << endl;

    cout << "Before swapping doubles: da = " << da << ", db = " << db << endl;
    Swap(da, db);
    cout << "After swapping doubles: da = " << da << ", db = " << db << endl << endl;

    cout << "Before swapping strings: sa = \"" << sa << "\", sb = \"" << sb << "\"" << endl;
    Swap(sa, sb);
    cout << "After swapping strings: sa = \"" << sa << "\", sb = \"" << sb << "\"" << endl;

    return 0;
}

或者为了压缩代码，使用宏函数来简化

#include <iostream>
#include <string>

// 定义 typedef
typedef int IntType;
typedef double DoubleType;
typedef std::string StringType;

// 宏定义 Swap
#define SWAP(Type, a, b) do { \
    Type tmp = (a); \
    (a) = (b); \
    (b) = tmp; \
} while(0)

int main() {
    IntType a = 10, b = 20;
    DoubleType c = 10.5, d = 20.5;
    StringType s1 = "hello", s2 = "world";

    // 交换整型变量
    SWAP(IntType, a, b);
    std::cout << "After swapping, a = " << a << ", b = " << b << std::endl;

    // 交换双精度浮点型变量
    SWAP(DoubleType, c, d);
    std::cout << "After swapping, c = " << c << ", d = " << d << std::endl;

    // 交换字符串变量
    SWAP(StringType, s1, s2);
    std::cout << "After swapping, s1 = " << s1 << ", s2 = " << s2 << std::endl;

    return 0;
}

但是 众所周知，宏不具备 类型安全性，我们尝试在宏定义版本中添加一个错误的示例，看看会发生什么：

// 尝试交换不同的类型
SWAP(a, s1);

当尝试编译这段代码时，编译器不会报错，因为宏定义在预处理阶段被展开，而编译器在那时还没有进行类型检查。这可能会导致运行时错误。

我们可以使用 visual studio 提供的 工具来演示 这一过程 （工具 --》命令行 --》开发者工具）

cl /P /Fi"preprocessed_output.cpp" source_file.cpp

这里：

  • /P 指示预处理器输出经过预处理的源代码。
  • /Fi"preprocessed_output.c" 指定预处理后的输出文件名。
cl /c /Fo"compiled_object.obj" preprocessed_output.cpp

这里：

  • /c 表示只编译，不链接。
  • /Fo"compiled_object.obj" 指定输出的目标文件名。
link /OUT:executable_name.exe compiled_object.obj other_objects.obj

这里：

  • /OUT:executable_name.exe 指定输出的可执行文件名。
  • compiled_object.obj other_objects.obj 列出了要链接的对象文件。

并且 使用宏函数编程 也不利于 调试，由于宏定义在预处理阶段被展开，所以在调试时，宏定义的位置信息会被抹去，这使得定位错误变得困难。

但在现代 C++ 中，模板函数提供了更好的安全性、可读性和维护性。

#include <iostream>
#include <string>

// 模板函数 swap
template<typename T>
void swap(typename T& a, typename T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int a = 10, b = 20;
    double c = 10.5, d = 20.5;
    std::string s1 = "hello", s2 = "world";

    // 交换整型变量
    swap(a, b);
    std::cout << "After swapping, a = " << a << ", b = " << b << std::endl;

    // 交换双精度浮点型变量
    swap(c, d);
    std::cout << "After swapping, c = " << c << ", d = " << d << std::endl;

    // 交换字符串变量
    swap(s1, s2);
    std::cout << "After swapping, s1 = " << s1 << ", s2 = " << s2 << std::endl;

    return 0;
}

函数模板的结构

以一个大小比较的模板函数为例

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

  1. typename T 定义了一个类型参数 T，它是泛型的占位符，表示在调用模板函数时将被替换为实际类型的变量 ( 如 int char double )。

  2. typename 关键字用来声明类型参数。在某些上下文中，可以省略 typename 关键字 。

例如上文的函数模板可以简写为：

template<typename T>
T max(T a, T b)
{
	return b < a ? a: b;
}
  1. 类型参数的约束. 类型参数 T 必须支持 < 运算符，因为 max 函数使用了这个运算符来比较 a 和 b。
    • 对于基本类型如 int 或 double，这是默认支持的；而对于自定义类型，你需要显式地提供这样的运算符。

比如 自定义一个类型，使用我们的函数模板

#include <iostream>

// 自定义类 Point
class Point {
public:
    int x, y;

    Point(int x, int y) : x(x), y(y) {}

    // 重载 < 运算符
    bool operator<(const Point& other) const {
        if (x == other.x) {
            return y < other.y;
        }
        return x < other.x;
    }
};

// 模板函数 max
template<typename T>
T max(T a, T b) {
    return b < a ? a : b;
}

int main() {
    Point p1(1, 2);
    Point p2(3, 4);

    // 使用 max 函数模板比较 Point 类型的对象
    Point maxPoint = max(p1, p2);
    std::cout << "The maximum point is (" << maxPoint.x << ", " << maxPoint.y << ")" << std::endl;

    return 0;
}

在C++17之前，模板参数类型T通常需要满足可复制的要求，这是因为模板中的函数如果返回T类型的值，那么这个值就需要能够被复制。但是，有时候我们可能想要使用不可复制的类型作为模板参数，例如std::unique_ptr这样的独占所有权智能指针。

为了支持不可复制类型的使用，C++17引入了结构化绑定和std::optional、std::variant等新特性，同时也引入了std::move和std::forward等机制来更好地处理右值引用和移动语义。

结构化绑定允许你直接从一个容器或者元组中解构数据到多个变量中，而不需要显式地调用std::tie。这对于处理返回非复制类型的情况非常有用，因为你可以在不复制数据的情况下直接获取这些值。

  • std::optional<T>：可以表示一个可能不存在的值，它要么包含一个T类型的值，要么什么也不包含。
  • std::variant：可以表示几种不同类型的值之一，它只存储其中一个类型的数据。

这些类型可以帮助我们在不复制数据的情况下处理模板参数类型。

std::move和std::forward可以用来有效地移动数据，而不是复制它们。这在处理不可复制类型时非常重要。

下面是一个示例，展示了如何在C++17中返回一个不可复制的类型：

#include <memory>
#include <utility> // for std::forward

template<typename T>
T process(T&& t) {
    // 假设这里有一些处理逻辑
    return std::forward<T>(t); // 返回一个完美转发的T
}

int main() {
    auto p = std::make_unique<int>(42);
    auto result = process(std::move(p)); // 不复制 p，而是移动它
    return 0;
}

在这个例子中，process函数接受一个通用引用T&&，并且通过std::forward<T>(t)返回该值。这样，即使T是不可复制的类型（如std::unique_ptr），也可以通过移动构造而非复制构造来返回。

示例：使用std::optional
假设我们有一个函数，它可能会返回一个值，也可能不返回任何东西。我们可以使用std::optional来包装这个值：

#include <optional>

template<typename T>
std::optional<T> processOptional(T&& t) {
    if (/* some condition */) {
        return std::forward<T>(t);
    } else {
        return std::nullopt;
    }
}

int main() {
    auto p = std::make_unique<int>(42);
    auto result = processOptional(std::move(p));
    if (result) {
        // 使用 *result
    }
    return 0;
}

在这个例子中，processOptional函数返回一个std::optional<T>，它可以包含一个T类型的值或者为空。这样就可以安全地处理不可复制的类型，同时提供一种清晰的方式来表达可能不存在的结果。

模板的实例化

这是一个程序运行的流程图，可见 模板实例化 是在编译过程中发生的，具体来说是在编译的早期阶段，即模板的解析和实例化阶段。这个阶段通常发生在预处理之后，但在整个编译流程完成之前。

  1. Source Code (源代码): 用户编写的原始程序代码。
  2. Preprocessing (预处理): 包括宏替换、头文件包含等。
  3. Macro Expansion (宏扩展): 宏定义被其定义的内容所替代。
  4. Compilation (编译): 将预处理后的源代码转换为汇编代码，包括语法和类型检查。
  5. Template Instantiation (模板实例化): 为模板定义创建具体的实例。
  6. Assembly (汇编): 将编译后的汇编代码转换为机器语言的目标代码。
  7. Linking (链接): 将多个目标文件组合成一个可执行文件。
  8. Executable (可执行文件): 包含所有必需的机器代码和资源的文件。
  9. Runtime Environment (运行时环境): 加载并执行可执行文件。
Macro Expansion
Template Instantiation
Load & Execute
Program Execution
Source Code
Preprocessing
Compilation
Assembly
Linking
Executable
Macro Expansion
Template Instantiation
Runtime Environment
Output

对于模板 (它发生在)，它允许你在编译时根据不同的类型生成不同的代码实例。

#include <iostream>

// 模板函数
template<typename T>
T max(T a, T b) {
    return b < a ? a : b;
}

int main() {
    int x = 10, y = 20;
    double d1 = 10.5, d2 = 20.5;

    int maxInt = max(x, y);
    double maxDouble = max(d1, d2);

    std::cout << "Max of " << x << " and " << y << " is: " << maxInt << std::endl;
    std::cout << "Max of " << d1 << " and " << d2 << " is: " << maxDouble << std::endl;

    return 0;
}

在这个示例中，当我们调用 max 函数时，编译器会根据传递的类型自动实例化相应的函数版本。例如，对于整数，它会生成一个整数版本的 max 函数；对于双精度浮点数，它会生成一个双精度浮点数版本的 max 函数。

对于 宏替换 而言，MAX 宏定义只是一个简单的文本替换。无论你在哪里使用 MAX(a, b)，预处理器都会将其替换为 ((a) > (b) ? (a) : (b))。这意味着对于所有类型，宏定义都会执行相同的替换，不考虑类型的安全性（宏定义在预处理阶段展开，因此在调试时很难追踪到原始的宏定义位置）。

#include <iostream>

// 宏定义
#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main() {
    int x = 10, y = 20;
    double d1 = 10.5, d2 = 20.5;

    int maxInt = MAX(x, y);
    double maxDouble = MAX(d1, d2);

    std::cout << "Max of " << x << " and " << y << " is: " << maxInt << std::endl;
    std::cout << "Max of " << d1 << " and " << d2 << " is: " << maxDouble << std::endl;

    return 0;
}
两阶段实例化

  1. 解析阶段 (Parsing)：在这个阶段，编译器读取源代码并构建抽象语法树（AST）。在这个过程中，模板定义的语法正确性会被检查，但是模板的具体实例还没有被创建。这意味着在这个阶段，编译器无法评估依赖于模板参数的表达式的值。

  2. 实例化阶段 (Instantiation)：当模板被用来创建特定类型的实例时，这个过程被称为模板实例化。在这个阶段，编译器会创建具体的函数或类，并且能够评估模板参数的实际值。模板实例化时，所有依赖于模板参数的表达式都会被评估。

下图是一个 C++ 模板实例化两阶段的流程图

  1. Template Declaration 表示模板声明。
  2. Resolution Phase 表示解析阶段，在这里进行类型和表达式的检查。
  3. Template Definition Checked 表示模板定义已经过检查。
  4. Template Usage 决策节点询问是否有模板的使用。
  5. 如果没有使用，则 Compilation Ends，编译结束。
  6. 如果有使用，则进入 Instantiation Phase（实例化阶段）。
  7. Parameter Deduction 表示根据模板使用情况推导出模板参数。
  8. Code Generation for Specific Types 表示为特定类型生成代码。
  9. Specific Code Compiled 表示特定类型的代码已经被编译。
Type and Expression Check
No Usage
Usage
Parameter Deduction
Template Declaration
Resolution Phase
Template Definition Checked
Template Usage
Compilation Ends
Instantiation Phase
Code Generation for Specific Types
Specific Code Compiled

可以使用 https://cppinsights.io/ 网站，从编译器视角查看 实例化的过程。

当模板被用来创建具体的类型时，我们可以使用一个 静态断言 对模板参数 类型进行评估

#include <iostream>
#include <type_traits>

template<typename T>
void print(T value)
{
    static_assert(std::is_integral<T>::value, "T must be an integral type");

    std::cout << value << '\n';
}

int main()
{
    print(5); // 实例化为 int 类型，正常工作

    print(3.14f); // 实例化时失败，因为 float 不满足 is_integral 断言

    return 0;
}

总结一下：
本节内容主要介绍了：

  1. 我们为什么需要模板
  2. 模板和宏替换的区别
  3. 函数模板的结构
  4. 模板两阶段实例化

下一节我们将介绍 C++ 模板的其他内容：

  1. 模板参数的类型推导
  2. 多类型的模板参数
丁金金
关注
C++泛型编程（模板）
qq_46518045的博客
02-28 489
c++主要提供两种模板函数模板和类模板 1，函数模板的作用： 建立一个通用函数，其函数返回值类型和参数类型可以不具体制定，用一个虚拟的类型来代表。 template：关键字template表明是声明模板。typename可以用class代替，cal名称可以替换叫做通用数据类型。 #include<iostream> using namespace std; template<typename cal> void swap(int &a,int &b) { int
C++泛型编程指南之函数模板优先级匹配
这是一个c++热爱者的博客哟
08-10 878
完美匹配 (1)：参数类型与函数参数类型完全相同，或者参数是左值引用且指向相同类型的对象。匹配需要微调 (2)：数组变量衰减为指针，或添加const限定符以匹配参数类型。类型提升匹配 (3)：小整型和浮点型的自动提升。标准转换匹配 (4)：标准转换或派生类到基类的转换。用户定义的转换匹配 (5)：通过构造函数或转换运算符进行的转换。省略号匹配 (6)：省略号参数可以匹配多种类型，但对于某些类型可能有限制。
C++泛型编程指南==》模板重载决议
这是一个c++热爱者的博客哟
08-08 597
重载解析仅应用于命名函数的调用。通过函数指针或指向成员函数的指针进行的调用不适用重载解析。类函数宏不支持重载，因此不需要进行重载解析。重载解析的目标是确定最佳匹配的函数，以便于正确地调用。完美匹配 (1)：参数类型与函数参数类型完全相同，或者参数是左值引用且指向相同类型的对象。匹配需要微调 (2)：数组变量衰减为指针，或添加const限定符以匹配参数类型。类型提升匹配 (3)：小整型和浮点型的自动提升。标准转换匹配 (4)：标准转换或派生类到基类的转换。用户定义的转换匹配 (5)
C++ 泛型编程指南 可变参模板指南
这是一个c++热爱者的博客哟
02-04 2160
cout
现代泛型编程指南==》函数模板
这是一个c++热爱者的博客哟
08-07 898
当参数按引用声明时，所有实参必须具有相同的类型。当参数按值声明时，允许进行简单的转换，但转换后的类型必须匹配。如果实参的类型不兼容，或者不能通过简单的转换匹配，那么调用将导致编译错误。方法1：适用于你想要显式指定返回类型的情况。方法2：适用于你想让编译器推导返回类型的情况。方法3：适用于你想自动选择两个类型之间的公共类型作为返回类型的情况。方法二的局限性[[#方法二的局限性]]方法三的注意事项使用b < a?a : b更加稳健，因为它不依赖于运算符的存在。
C++ 泛型编程指南 可变参数模板2
这是一个c++热爱者的博客哟
10-08 3564
可变参数模板是一种可以接受任意数量模板参数的模板。折叠表达式是一种用来处理可变数量参数（比如模板参数包）的方式。它能帮你把这些参数运算组合在一起。op代表运算符：下列 32 个二元运算符之一：+ - * / % ^ & | = < > > += -=->*。在二元折叠中，两个运算符必须相同。pack代表参数包：含有未展开的形参包且在顶层不含优先级低于转型（正式而言，是 转型表达式）的运算符的表达式。
16 C++ 模板与泛型编程
surfaceyan的博客
05-17 608
模板是C++中泛型编程的基础。一个模板就是一个创建类或函数的蓝图或公式。当使用一个vector这个样的泛型类型，或find这样的泛型函数时，我们提供足够的星系，将蓝图转换为特定的类或函数。这种转换发生在编译时。function template    模板参数列表template parameter list   模板参数template parameter   模板实参template argument 非类型模板参数 nontype parameter inline和constexpr 类模板 实
C++ 泛型编程指南 非类型模板参数
这是一个c++热爱者的博客哟
10-06 3826
与前几章的栈实现不同，这里可以通过使用固定大小的元素数组来实现栈。好的解决方案是让堆栈的用户指定数组的大小，作为 堆栈的最大容量。此外，还会展示非类型函数模板参数的示例，并讨论了这种技术的限制。这个类提供了一个简单而有效的方式去实现一个带有固定最大容量的栈，充分使用了 C++ 的模板和断言特性来进行类型安全的编程以及运行时检查。接受任意类型的非类型参数，还可以传递字符串作为常量数组（甚至可以是静态的局部声明）。通过这个类的声明，当我们在使用堆栈时，元素数量的类型取决于模板参数的类型定义。
C++ 泛型编程指南 类模板，类型推断，特化，别名模板
这是一个c++热爱者的博客哟
10-06 3932
声明类模板类似于声明函数模板。在定义具体内容之前，需要先声明一个或多个作为模板类型参数的标识符。通常，这个标识符用 表示： 在这里，可以用关键字 代替 ： 在类模板内部， 可以像普通类型一样用于声明成员变量和成员函数。在这个例子中， 被用于声明 中元素的类型，用于声明成员函数 的参数类型，也被用于成员函数 的返回类型： 这个类的类型是 ，其中 是模板参数。在声明时，除非可以推断出模板参数的类型，否则必须使用 （ 后面必须跟着 ）。不过，如果在类模板内部使用 而不是 ，则表示这个内部类的模板参数
C++泛型编程深度探索：模板完全指南
《C++Templates全览》不仅提供了基础的模板使用教程，还深入挖掘了模板技术的边界，对于希望提升C++泛型编程能力的开发者来说是一本不可多得的参考书。通过阅读这本书，开发者可以更好地掌握C++模板的各个方面，从而...
C++泛型编程深度探索：模板元编程与STL实战
"《C++ Templates》是一本深入探讨C++泛型编程的英文...《C++ Templates》这本书提供了关于C++泛型编程的全面指南，无论你是初学者还是经验丰富的开发者，都可以从中获得宝贵的见解和技巧，进一步提升你的C++编程能力。
C++泛型编程深入指南
4. STL、Loki和Boost库的分析：除了基本的模板概念，书中还可能涉及STL（标准模板库）、Loki和Boost等库的使用和实现细节，这些库极大地扩展了C++泛型编程的功能，为开发者提供了丰富的工具和设计模式。 《C++ ...
C++泛型编程深入指南： Templates完全解析
本书深入探讨了C++中的泛型编程，特别是templates的各个方面，包括语法、语义、应用、专家建议、前沿发展以及库源码分析和技术解析。" C++ Templates是C++语言中的一种强大的特性，它允许程序员创建泛型代码，即...
C++泛型编程深度解析：Templates完全指南
本书深入探讨C++泛型编程的关键元素——模板（Templates），涵盖了泛型编程的各种层面，包括语法、语义、应用、专家建议、前沿发展、库源码分析和技术解析。" C++模板是泛型编程的核心工具，它允许程序员编写可重用...
42 C 语言 typedef：为基本数据类型、数组、指针、结构体、共用体起别名
Thanks_ks的IT探秘之旅
10-09 659
本文全面介绍了 C 语言中 typedef 的使用方法和技巧。从为基本类型如 int、unsigned char 起别名，到为结构体、共用体、指针以及数组等复杂类型起别名，都进行了详细的阐述。通过具体示例，展示了如何分开定义结构体和别名、如何在结构体定义中直接使用 typedef、如何为匿名结构体起别名等高级用法。此外，还探讨了为指针和数组类型起别名的方法，并给出了综合案例，帮助读者更好地理解和应用 typedef。
C++，STL 028（24.10.11）
Erif_Liu的博客
10-12 206
利用sort排序算法来对deque容器进行排序。
C++ 游戏开发技术选型指南
最新发布
进击的码农
10-12 559
在使用C++进行游戏开发时，选择合适的技术栈和工具链是项目成功的关键之一。我们探讨了游戏开发常用的一些引擎、示例代码的实现、性能优化及潜在问题解决方案。通过合理选择和配置，可以有效提高开发效率和产品质量。在此过程中，我深刻感受到技术的选择与应用只是成功的一部分，持续学习和思考如何创新更是推动项目成功的动力。希望这篇博客能对你的项目有所帮助，并期待你在开发过程中创造出更多技术上的创新与突破。
大话C++：第15篇 友元
whccf的博客
10-09 971
友元（Friend）是C++中的一个特殊概念，它允许一个类或函数访问另一个类的私有和保护成员。友元可以是一个函数，也可以是一个类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

丁金金

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值