C++ 初识模板

康熙38bdc

已于 2024-06-07 18:39:08 修改

阅读量935

点赞数 21

分类专栏： C++ 文章标签： c++ 开发语言

于 2024-04-21 17:50:01 首次发布

本文链接：https://blog.csdn.net/wxk2227814847/article/details/138036260

版权

C++ 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

本文介绍了C++中的泛型编程，包括函数模板的概念、格式、实例化方法，以及类模板的定义和应用。通过模板，实现代码复用和类型无关编程，提升代码的通用性和效率。

摘要由CSDN通过智能技术生成

（图像由AI生成）

0.前言

在 C++ 中，模板是一种强大的编程工具，可以实现泛型编程。泛型编程是一种编程范式，通过在代码中使用参数化类型，使得代码更加通用，可以应用于不同类型的数据。模板可以应用于函数和类，分别称为函数模板和类模板。下面，就让我们开始认识模板，走进泛型编程的世界吧！

1.泛型编程

泛型编程是一种编程范式，旨在通过使用参数化的类型来提高代码的复用性和通用性。这种范式允许程序员编写与类型无关的代码，适用于多种数据类型，从而提高代码效率和质量。

在没有泛型编程的情况下，当我们需要编写一个可以交换两个变量值的 Swap 函数时，很可能需要为每种数据类型编写一个具体的函数。例如，你可能需要为整型、双精度浮点型和字符型分别实现 Swap 函数：

void Swap(int& left, int& right) {
    int temp = left;
    left = right;
    right = temp;
}

void Swap(double& left, double& right) {
    double temp = left;
    left = right;
    right = temp;
}

void Swap(char& left, char& right) {
    char temp = left;
    left = right;
    right = temp;
}

这些函数的实现在逻辑上是相同的，唯一的区别在于操作的数据类型不同。这种方式显然不符合 "Don't Repeat Yourself" (DRY) 的原则，因为相同的逻辑被重复写了多次。

为了解决代码重复的问题，并使函数能够处理不同的数据类型，泛型编程被引入。在 C++ 中，这是通过模板来实现的。

泛型编程的核心思想是使用参数化类型，也就是说，在编写函数或类时不指定具体的类型，而是使用一个占位符（类型参数），这个占位符在函数或类被使用时才被替换为实际的类型。这样，上面的三个 Swap 函数可以被一个模板函数取代：

template<typename T>
void Swap(T& left, T& right) {
    T temp = left;
    left = right;
    right = temp;
}

这个模板函数可以用于任何数据类型，从基本的数据类型（如 int, double, char）到用户定义的类型。你只需要一次定义，就可以用于多种类型，而不需要为每一种类型重写代码。

下面，就让我们进一步了解函数模板的概念、格式等相关内容。

2.函数模板

2.1概念

函数模板是 C++ 提供的一种工具，用于实现泛型编程。通过函数模板，程序员可以定义一个通用的函数框架，让编译器根据实际传入的参数类型自动生成相应的函数实例。这种方法不仅能够处理不同的数据类型，还可以应对未来可能需要支持的新类型，极大地增强了代码的通用性和灵活性。

函数模板的基本思想是：在编写时不指定具体的数据类型，而是用一个或多个模板参数（模板类型参数）来代替具体类型。当函数被调用时，编译器根据传入的实参自动推导出模板参数的类型，并生成对应类型的函数实例。这个过程称为模板的实例化。

2.2格式

函数模板的定义遵循一定的语法格式。下面是一个基本的函数模板定义的格式：

template <typename T>
ReturnType FunctionName(ParameterType parameter) {
    // 函数体
}

在这个格式中，关键部分如下：

template <typename T>：这行代码告诉编译器以下定义是一个模板，其中 T 是一个模板参数，它代表一种数据类型。关键字 typename 可以被 class 替换，二者在这里意义相同，都表示 T 是一个类型占位符。
ReturnType：函数的返回类型，它可以是任意类型，包括模板类型参数 T。
FunctionName：函数名。这是模板实例化后生成的每个函数的名称。
ParameterType parameter：参数列表，参数类型可以是模板类型参数 T，也可以是其他任何具体的类型。参数可以有多个，也可以有不同的类型。

一个实际的函数模板示例如下，它用于返回两个值中的较大者：

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

这个 Max 函数可以用于任何支持比较操作符 > 的数据类型。例如，你可以用它来比较两个整数、两个浮点数，甚至两个字符串。调用示例：

int i = Max(10, 5);           // 实例化一个比较 int 的 Max 函数
double d = Max(5.3, 10.6);    // 实例化一个比较 double 的 Max 函数
std::string s = Max(std::string("apple"), std::string("banana")); // 实例化一个比较 std::string 的 Max 函数

在这些例子中，编译器会自动推导模板参数 T 的具体类型，并生成相应的函数实例。这种自动类型推导和实例化机制使得函数模板非常强大且灵活，是 C++ 泛型编程的核心工具之一。

2.3原理

函数模板的原理涉及到几个关键的概念和编译时的行为，主要包括模板的定义、实例化和类型推导。这些机制共同工作，使得函数模板可以灵活地应用于各种数据类型，同时保持高效的执行速度。

当定义一个函数模板时，你实际上没有生成任何代码。函数模板本身更像是一个蓝图或者配方，指示编译器如何生成具体的函数实例。模板定义包含了所有必要的逻辑，但留给编译器在具体类型确定时才生成代码。

C++11 引入的自动类型推导进一步简化了模板的使用。在调用模板函数时，不必显式指定参数类型，编译器能根据传递的实参自动推导出模板参数的类型。这使得模板函数调用更加简洁，降低了模板使用的复杂性。

在编译时，对于每个通过显式或隐式实例化生成的模板函数，编译器会生成相应类型的函数实体。这意味着，如果你的模板函数被用于三种不同的类型，则编译器将生成三个不同的函数。每个生成的函数都是针对特定类型优化的，这避免了运行时类型检查或转换，从而提高执行效率。

由于模板函数的代码在编译时生成，编译器有机会对生成的代码进行优化，比如内联小型模板函数。内联可以消除函数调用的开销，但同时增加了编译后的代码量。这种权衡是性能优化中常见的考虑。

2.4函数模板的实例化

函数模板的实例化是指从模板生成具体函数代码的过程。这个过程可以是隐式的，由编译器自动根据函数调用的上下文完成；也可以是显式的，由程序员手动指定模板参数。理解这两种实例化方式对于高效地使用函数模板至关重要。

2.4.1隐式实例化

在隐式实例化中，编译器根据模板函数调用时提供的参数类型自动推导出模板参数的具体类型。编译器使用这些具体的类型来生成相应的函数版本。

template<typename T>
void print(T value) {
    std::cout << value << std::endl;
}

int main() {
    print(123);        // 隐式实例化为 print<int>(int)
    print(3.14);       // 隐式实例化为 print<double>(double)
    print("Hello");    // 隐式实例化为 print<const char*>(const char*)
}

在这个例子中，print 函数模板被三次调用，每次调用都基于传递给函数的实参类型（整数、浮点数和字符串字面值），编译器自动推导出模板参数 T 的类型，并生成对应的函数实例。

2.4.2显式实例化

显式实例化则是程序员直接指定模板参数的具体类型，告诉编译器生成特定类型的模板函数实例。这种方式使得生成的函数类型不依赖于调用时的参数类型，可以用于预先生成特定的模板实例或当模板参数不能被自动推导时使用。

template<typename T>
void print(T value) {
    std::cout << value << std::endl;
}

// 显式实例化定义
template void print<int>(int);
template void print<double>(double);
template void print<const char*>(const char*);

int main() {
    print(123);        // 使用预先实例化的 print<int>(int)
    print(3.14);       // 使用预先实例化的 print<double>(double)
    print("Hello");    // 使用预先实例化的 print<const char*>(const char*)
}

在这个例子中，print 函数的每种类型实例已经在全局范围内显式实例化。这意味着编译器在遇到这些函数调用时，不需要再进行类型推导和函数实例化，直接使用已经生成的实例。这可以用于优化编译时间，或者在模板的定义与实例化需要在不同编译单元中进行时使用。

2.5模板参数的匹配原则

函数模板的参数匹配是 C++ 中一个复杂但非常强大的特性，特别是当非模板函数和同名的函数模板同时存在时。这里，我们将探讨三个关键的规则，每个规则都将通过代码进行详细解释。

规则 1：非模板函数与同名模板函数的共存

在 C++ 中，一个非模板函数可以与一个同名的函数模板共存，且该模板可以被实例化为与非模板函数具有相同签名的函数。这种情况下，非模板函数被称为模板的显式专用化。

#include <iostream>

// 非模板函数
void print(int x) {
    std::cout << "Non-template function: " << x << std::endl;
}

// 函数模板
template<typename T>
void print(T x) {
    std::cout << "Template function: " << x << std::endl;
}

int main() {
    print(10);   // 调用非模板函数
    print<>(10); // 强制使用模板实例化
}

在这个例子中，print(10) 会调用非模板函数，因为它提供了一个精确的匹配。而 print<>(10) 通过空的尖括号 <> 强制使用模板，即使存在一个非模板的完全匹配。

规则 2：非模板函数的优先级

如果存在同名的非模板函数和函数模板，且它们都可以处理相同的调用，非模板函数通常会被优先选择，因为它提供了一个更为具体的匹配。但是，如果函数模板能够提供一个更好的匹配，则会选择模板函数。

#include <iostream>

void process(double x) {
    std::cout << "Non-template function: " << x << std::endl;
}

template<typename T>
void process(T x) {
    std::cout << "Template function: " << x << std::endl;
}

int main() {
    process(10.5); // 调用非模板函数
    process(10);   // 调用模板函数，因为模板提供了更好的匹配（int 匹配）
}

这里，process(10.5) 直接调用非模板函数，因为它精确匹配 double 类型。但对于 process(10)，尽管非模板函数可行（通过隐式转换），编译器选择了模板函数，因为模板提供了对 int 类型的直接匹配，没有需要类型转换。

3.类模板

类模板是 C++ 泛型编程的另一个核心特性，允许程序员编写一个框架来生成可以操作任意类型数据的类。类似于函数模板，类模板提供了代码的复用性与类型的灵活性。

3.1类模板的定义格式

类模板的定义与函数模板类似，通过在类定义前加上 template 关键字和一系列模板参数来声明。这些参数可以在类内的成员函数、成员变量和嵌套类型中使用。

基本语法：

template <typename T>
class ClassName {
public:
    T memberVariable;

    void memberFunction(T param) {
        // 函数体
    }
};

示例代码：

template <typename T>
class Box {
public:
    T width, height, depth;

    // 构造函数
    Box(T w, T h, T d) : width(w), height(h), depth(d) {}

    // 成员函数，计算体积
    T volume() const {
        return width * height * depth;
    }
};

在这个例子中，Box 类模板可以用于创建存储任何类型的 width、height 和 depth 的盒子，并计算其体积。由于使用了模板参数 T，这个类可以用于 int、double 或其他任何支持乘法运算的数据类型。

3.2类模板的实例化

类模板的实例化是在编译时根据指定的具体类型参数创建类的过程。实例化的结果是一个具体的类，具有与模板参数相对应的数据类型。

隐式实例化：当你创建一个模板类的对象并提供具体类型时，编译器会自动为你生成该类型的类实例。

Box<int> intBox(10, 20, 30);
std::cout << "Volume of intBox: " << intBox.volume() << std::endl;

显式实例化：你也可以显式地告诉编译器为特定类型生成模板类的实例，这常用于减少编译时间，特别是当模板在多个文件中使用时。

template class Box<double>;  // 显式实例化

int main() {
    Box<double> doubleBox(10.5, 20.5, 30.5);
    std::cout << "Volume of doubleBox: " << doubleBox.volume() << std::endl;
}

在显式实例化中，template class Box<double>; 指示编译器为 double 类型生成 Box 类模板的全部成员定义。之后，在其他代码中创建 Box<double> 的对象时，不需要再次实例化。

4.结语

通过本文的介绍，我们可以看到，C++ 模板是一种强大的工具，使得编程变得更为灵活和通用。无论是函数模板还是类模板，它们都提供了实现泛型编程的基础，允许代码以类型无关的方式被重用和适应不同的数据需求。这不仅增加了代码的复用性和可维护性，还提高了程序的效率和可靠性。掌握C++模板是每个C++程序员提升编程技能的关键步骤，也是深入理解现代C++设计和实现的基础。

康熙38bdc

关注

21
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
C++ 初识模板

通过本文的介绍，我们可以看到，C++ 模板是一种强大的工具，使得编程变得更为灵活和通用。无论是函数模板还是类模板，它们都提供了实现泛型编程的基础，允许代码以类型无关的方式被重用和适应不同的数据需求。这不仅增加了代码的复用性和可维护性，还提高了程序的效率和可靠性。掌握C++模板是每个C++程序员提升编程技能的关键步骤，也是深入理解现代C++设计和实现的基础。
复制链接

扫一扫