【第六节】C++中的模板

最新推荐文章于 2024-06-28 11:04:31 发布

攻城狮7号

最新推荐文章于 2024-06-28 11:04:31 发布

阅读量1k

点赞数 24

分类专栏： C++编程从入门到实践文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/linshantang/article/details/139293798

版权

C++编程从入门到实践专栏收录该内容

13 篇文章 0 订阅

订阅专栏

前言

模板是C++编程中的一种强大工具，它允许程序员创建具有通用数据类型的函数库和类库。作为支持参数多态性的机制，模板极大地增强了代码的复用性和灵活性。

在C++语言中，程序的结构主要由函数和类组成，而模板则提供了两种关键的形式：

A: 函数模板 - 这是一种定义，允许函数根据传递的参数类型自动适应，从而实现对不同数据类型的通用操作。

B: 类模板 - 类似于函数模板，类模板允许创建可以处理多种数据类型的类，使得类的实例化可以根据实际使用的数据类型进行定制。

通过这两种模板形式，C++程序员能够设计出更加通用和可扩展的代码，有效提升软件开发的效率和质量。

一、函数模板

考察两个swap()函数，一个交换整型数，一个交换浮点数。尽管函数的功能一样、仅处理数据类型不同，但对有强数据类型校验的C++语言，必须使用函数重载，分别编写代码。

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

void swap(float& a, float& b) {
    float temp = a;
    a = b;
    b = temp;
}

这两个函数的参数个数、实现代码是相同的，只有形参的类型不同。如果将两函数中的int和float进行参数化,使用参数T替代,则交换任何一对数据类型的变量(包括类对象)可以定义为:

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

有了上述定义，对任一类型T的两个变量或类对象(x1,x2)，函数调用swap(x1.x2)，编译器都能理解并执行函数模板所确定的功能。
函数模板提供了具有处理相同功能的一类函数的抽象，它以任意类型T为参数、其定义形式如下:

template<参数化类型名表><返回类型〉<函数名>(<参数表>)
{
//<函数体>
}

template<typename T_TYPE>int fun(T_TYPE NUmA, T_TYPE NumB)
{
//……
}

        其中,template 是定义函数模板的关键字,<参数化类型名表>可以包含基本数据类型,也可以包含类类型如果是类类型，则需加关键字class，例如:
template <class T_TYPE>
        函数模板是对一组函数的描述,它不是一个实实在在的函数，表示每次它能单独处理在类型形式参数中说明的数据类型。编译器不会为其产生任何执行代码。
        当编译器发现有函数调用:函数名(实参数)，当实参数与函数模板形参数相匹配时，则产生一个重载函数。该重载函数与函数模板实现功能相同(函数体定义相同),该重载函数称为模板函数(template function)。
        下面举例说明了函数模板的定义和使用方法:

#include <iostream>
using namespace std;

template <typename T_TYPE>
T_TYPE my_max(T_TYPE NumA, T_TYPE NumB) {
    return NumA > NumB ? NumA : NumB;
}

int main() {
    cout << my_max(1, 2) << endl; 
    cout << my_max(1.2, 3.4) << endl; 
    cout << my_max('B', 'A') << endl; 
    system("pause"); 
    return 0;
}

函数模板是一种蓝图或定义，它本身并非一个具体的函数，而是通过使用泛型类型参数来描述一类函数的结构。当编译器遇到特定的函数调用时，它会根据函数模板生成一个具体的函数实例，即模板函数。这个模板函数是一个实际的、可执行的函数定义，包含了编译器生成的特定类型代码，能够直接在程序中执行。通过这种方式，函数模板提供了一种高效且灵活的方法来创建适用于多种数据类型的函数。

二、模块特化

模板的特化，亦可视为一种特殊的实例化过程，它包括隐式实例化和显式实例化两种形式。通常，我们所说的显式实例化即指模板的特化。特化的目的在于应对模板在实例化过程中可能遇到的特殊情况，确保模板能够正确处理特定类型的数据。

模板的特化主要分为两种：普通特化和偏特化，它们各自具有不同的特点：

普通特化：针对模板中所有替换类型中的某一种类型进行专门的处理，以适应该类型的特殊需求。

偏特化：针对模板中所有替换类型中的某一种类型的某些特定方面进行专门的处理，以优化或修正该类型的行为。

以一个比较大小的函数模板为例，该模板在设计时可能仅考虑了常规情况。然而，当参数为指针类型时，模板函数可能会错误地比较指针的地址而非指针所指向数据的大小。为了解决这一问题，我们需要对参数为指针类型的模板函数进行特化处理，确保其能够正确比较指针所指向数据的大小，而不是指针本身的地址。这种特化处理能够使模板更加灵活和精确地适应各种使用场景。

代码示例：

#include <iostream>

// 普通特化
template<typename T1, typename T2>
void myFunction(T1 a, T2 b) {
    std::cout << "General template for T1=" << typeid(T1).name()
        << ", T2=" << typeid(T2).name() << std::endl;
}

// 偏特化
template<>
void myFunction<int, int>(int a, int b) {
    std::cout << "Specialized template for int and int" << std::endl;
}


int main() {
    myFunction(3, 4);
    system("pause"); 
    return 0;
}

三、重载函数模板

在C++中，函数重载的解析遵循以下规则：

查找参数完全匹配的函数: 编译器首先查找完全匹配调用函数的参数列表的函数。如果找到一个精确匹配的函数，那么编译器将使用这个函数。
查找函数模板: 如果没有找到精确匹配的函数，编译器会查找函数模板。如果找到一个函数模板，它会尝试用调用参数实例化这个模板，生成一个新的函数。
通过类型转换产生参数匹配的函数: 如果没有找到精确匹配的函数或函数模板，编译器会尝试进行类型转换，以找到一个参数匹配的函数。这可能包括标准类型转换（如算术转换、派生类向基类的转换等）以及用户定义的类型转换。
寻找可变参数函数: 如果没有找到精确匹配的函数、函数模板或通过类型转换得到的匹配函数，编译器会查找是否有可变参数函数（如printf函数）可以接受可变数量的参数。
寻找省略号匹配的函数: 如果没有找到其他匹配的函数，编译器会查找是否有函数的参数列表中包含省略号（...），这通常用于可变参数函数。
错误报告: 如果上述步骤都无法找到匹配的函数，编译器将报告错误，表明没有找到可以调用的函数。

示例代码：

#include <iostream>
using namespace std;

// 普通函数
void print(int i) {
    std::cout << "int: " << i << std::endl;
}

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

// 通过类型转换产生参数匹配的函数
void print(double d) {
    std::cout << "double: " << d << std::endl;
}

int main() {
    int a = 5;
    double b = 3.14;

    // 调用精确匹配的函数
    print(a); // 输出: int: 5

    // 调用函数模板实例化产生的函数
    print(b); // 输出: double: 3.14

    // 调用通过类型转换产生参数匹配的函数
    print(42); // 输出: int: 42，因为42可以转换为int

    return 0;
}

四、类模板

在编程中，当我们需要定义一个一维数组或链表时，无论数组元素或链表结点是何种数据类型，它们的基本操作（如插入、删除、检索等）通常保持一致。例如，一个数组类可以处理任何类型的数据，而链表类也可以定义结点以适应不同的数据类型，但其基本操作流程不变。

然而，如果对于每种不同的数据类型，我们都必须重新定义一个新的类，这将导致大量的代码重复和维护上的困难。为了解决这个问题，我们可以引入类模板的概念。通过类模板，我们可以使用一个通用参数T来代表数组元素或链表结点的数据类型。这样，一个类模板就可以适用于多种数据类型，而不需要为每种类型单独编写类定义。这种方法极大地提高了代码的复用性和灵活性，减少了重复工作，使得类的实现更加高效和易于管理。

类模板的定义格式为:
template〈模板参数表>
class <类名>
{
//类体说明
}
其中 template 是关键字,<模板参数表>中可以有多个参数，其间用逗号分隔。

代码示例：

#include <iostream>
using namespace std;

template <typename T>
class Array {
private:
    T* elements;
    size_t size;

public:
    // 构造函数
    Array(size_t s) : size(s) {
        elements = new T[s];
    }

    // 析构函数
    ~Array() {
        delete[] elements;
    }

    // 复制构造函数
    Array(const Array& other) : size(other.size) {
        elements = new T[size];
        for (size_t i = 0; i < size; ++i) {
            elements[i] = other.elements[i];
        }
    }

    // 赋值运算符重载
    Array& operator=(const Array& other) {
        if (this != &other) {
            delete[] elements;
            size = other.size;
            elements = new T[size];
            for (size_t i = 0; i < size; ++i) {
                elements[i] = other.elements[i];
            }
        }
        return *this;
    }

    // 获取数组大小
    size_t getSize() const {
        return size;
    }

    // 获取元素
    T& operator[](size_t index) {
        if (index >= size) {
            throw std::out_of_range("Index out of range");
        }
        return elements[index];
    }

    // 常量版本获取元素
    const T& operator[](size_t index) const {
        if (index >= size) {
            throw std::out_of_range("Index out of range");
        }
        return elements[index];
    }
};

int main() {
    // 创建一个整型数组
    Array<int> intArray(5);
    for (size_t i = 0; i < intArray.getSize(); ++i) {
        intArray[i] = i * 2;
    }
    for (size_t i = 0; i < intArray.getSize(); ++i) {
        std::cout << intArray[i] << " ";
    }
    std::cout << std::endl;

    // 创建一个浮点型数组
    Array<float> floatArray(3);
    floatArray[0] = 3.14f;
    floatArray[1] = 2.71f;
    floatArray[2] = 1.61f;
    for (size_t i = 0; i < floatArray.getSize(); ++i) {
        std::cout << floatArray[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

类模板是为具有相同特性的一组类，定义的一种模式，它说明单个类怎样建立，这与类型声明说明单个对象是怎样建立类似。用模板实参数生成的类称为模板类，模板类可以生成对象。

五、总结

模板是C++中一种安全且高效的代码重用机制。它采用参数化类型的方式，使得在创建对象或函数时，通过传递不同的实参类型，可以改变其行为。无论是函数模板还是类模板，经过实例化后，可以生成具有不同数据类型的模板函数和模板类。尽管这些模板处理的数据类型可能各异，但它们的功能和实现逻辑始终保持一致。每个模板类的实例都是一个真实的对象，可以像其他类的对象一样进行操作和使用。

在C++中，一个显著的发展趋势是广泛采用标准模板库（STL），它已经成为许多编译器不可或缺的一部分。STL是一个基于模板的综合性类库，其中包含了诸如向量、链表和队列等数据结构，以及一些通用的排序和查找算法等。STL极大地减少了程序员需要重复编写的代码量，提高了编程的效率和代码的可维护性，为开发者提供了极大的便利。

攻城狮7号

关注

24
点赞
踩
25

收藏

觉得还不错? 一键收藏
打赏
0
评论
【第六节】C++中的模板

模板是C++编程中的一种强大工具，它允许程序员创建具有通用数据类型的函数库和类库。作为支持参数多态性的机制，模板极大地增强了代码的复用性和灵活性。在C++语言中，程序的结构主要由函数和类组成，而模板则提供了两种关键的形式：A:函数模板- 这是一种定义，允许函数根据传递的参数类型自动适应，从而实现对不同数据类型的通用操作。B:类模板- 类似于函数模板，类模板允许创建可以处理多种数据类型的类，使得类的实例化可以根据实际使用的数据类型进行定制。
复制链接

扫一扫