C++入门——模板

最新推荐文章于 2024-09-16 21:35:54 发布
最新推荐文章于 2024-09-16 21:35:54 发布
阅读量275 收藏
点赞数
分类专栏： C++ 文章标签： c++ 模板 泛型编程 template
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beilizhang/article/details/118468699
版权

参考链接

  1. https://www.bilibili.com/video/BV1et411b73Z?p=167

模板

模板的概念

  1. C++另一种编程思想称为泛型编程，主要利用的技术就是模板
  2. C++提供两种模板机制：函数模板和类模板

模板就是建立通用的模具，大大提高复用性

模板的特点

  1. 模板不可以直接使用，它只是一个框架
  2. 模板的通用并不是万能的

函数模板

函数模板作用

建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表

函数模板语法
template<typename T>
函数声明或定义

解释：
template——声明创建模板
typename——表明其后面的符号是一种数据类型，可以用class代替
T——通用的数据类型，名称可以替换，通常为大写字母

使用函数模板实现交互两个数
//函数模板
template<typename T>
void mySwap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

void test()
{
    int a = 10;
    int b = 20;
    //1、自动类型推导
    //mySwap(a, b);

    //2、显示指定类型
    mySwap<int>(a, b);
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}
函数模板主要事项
  1. 自动类型推导，必须推导出一致的数据类型T，才可以使用
  2. 模板必须要确定出T的数据类型，才可以使用
函数模板案例

案例描述：

  1. 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
  2. 排序规则从大到小，排序算法为选择排序
  3. 分别利用char数组和int数组进行测试
排序算法
template<class T>
void mySort(T arr[], int len)
{
    for (int i = 0; i < len; i ++)
    {
        int max = i;
        for (int j = i + 1; j < len; j ++)
        {
            if (arr[max] < arr[j])
            {
                max = j;
            }
        }
        if (max != i)
        {
            mySwap(arr[max], arr[i]);
        }
    }
}

//提供打印数组模板
template<class T>
void printArray(T arr[], int len)
{
    for (int i = 0; i < len; i ++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}

void test()
{
    //测试char数组
    char charArr[] = "badcfe";
    int num = sizeof(charArr) / sizeof(char);
    mySort(charArr, num);
    printArray(charArr, num);

    //测试int数组
    int intArr[] = {7, 5, 1, 3, 9, 2, 4, 6, 8};
    int num = sizeof(intArr) / sizeof(int);
    mySort(intArr, num);
    printArray(intArr, num);
}
普通函数与函数模板的区别
  1. 普通函数调用时可以发生自动类型转换（隐式类型转换）
  2. 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
  3. 如果利用显示指定类型的方式，可以发生隐式类型转换
普通函数与函数模板的调用规则
  1. 如果函数模板和普通函数都可以实现，优先调用普通函数
  2. 可以通过空模板参数列表来强制调用函数模板，如myPrint<>(a, b);
  3. 函数模板也可以发生重载
  4. 如果函数模板可以产生更好的匹配，优先调用函数模板
模板的局限性

模板的通用性并不是万能的，优先特点数据类型，需要用具体化方式做特殊实现

例如：

//利用具体化Person的版本实现代码，具体化优先调用
template<> bool myCompare(Person &p1, Person &p2)
{
    if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
    {
        return true;
    }
    else
    {
    return false;
    }
}

总结：

  1. 利用具体化的模板，可以解决自定义类型的通用化
  2. 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

类模板

类模板作用

建立一个通用类，类中的成员数据类型可以不具体指定，用一个虚拟的类型来代表

类模板语法
template<typename T>
类

解释：
template——声明创建模板
typename——表明其后面的符号是一种数据类型，可以用class代替
T——通用的数据类型，名称可以替换，通常为大写字母

例如：

template<class NameType, class AgeType>
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    void showPerson()
    {
        cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
    }
    NameType m_Name;
    AgeType m_Age;
};

void test()
{
    Person<string, int> p1("孙悟空", 999);
    p1.showPerson();
}
类模板与函数模板区别
  1. 类模板没有自动类型推导的使用方式，只能用显式指定类型方式
  2. 类模板在模板参数列表中可以有默认参数，例如：template<class NameType, class AgeType = int>
类模板中成员函数创建时机
  1. 普通类中的成员函数一开始就可以创建
  2. 类模板的成员函数在调用时才创建
类模板对象做函数参数

类模板实例化出的对象，向函数传参的方式一共有三种：

  1. 指定传入的类型——直接显示对象的数据类型
  2. 参数模板化——将对象中的参数变为模板进行传递
  3. 整个类模板化——将这个对象类型模板化进行传递

使用比较广泛的是第一种：指定传入的类型

指定传入的类型
void printPerson1(Person<string, int>&p)
{
    p.showPerson();
}

void test()
{
    Person<string, int>p("孙悟空", 100);
    printPerson1(p);
}
参数模板化
template<class T1, class T2>
void printPerson2(Person<T1, T2>&p)
{
    p.showPerson();
    cout << "T1的类型为：" << typeid(T1).name() << endl;
    cout << "T2的类型为：" << typeid(T2).name() << endl;
}

void test2()
{
    Person<string, int>p("猪八戒", 100);
    printPerson2(p);
}
整个类模板化
template<class T>
void printPerson3(T &p)
{
    p.showPerson();
    cout << "T的数据类型为：" << typeid(T).name() << endl;
}

void test3()
{
    Person<string, int>p("唐僧", 30);
    printPerson3(p);
}
类模板与继承
  1. 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型。例如class Son:public Base
  2. 如果不指定，编译器无法给子类分配内存
  3. 如果想灵活指定出父类中T的类型，子类也需变为类模板。例如：
template<class T1, class T2>
class Son2 :public Base<T2>
{
    T1 obj;
};

void test()
{
    Son2<int, char>S2;
}
类模板成员函数类外实现
template<class T1, class T2>
class Person
{
public:
    Person(T1 name, T2 age);

    void showPerson();

    T1 m_Name;
    T2 m_Age;
};

//构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
    this->m_Name = name;
    this->m_Age = age;
}

//成员函数类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
    cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
类模板分文件编写

问题：
类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

  1. 解决方式1：直接包含.cpp源文件（使用较少）
  2. 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制
类模板与友元
  1. 全局函数类内实现——直接在类内声明友元即可
  2. 全局函数类外实现——需要提前让编译器知道全局函数的存在

建议全局函数做类内实现，用法简单，而且编译器可以直接识别

//通过全局函数，打印Person信息

//提前让编译器知道Person类存在
template<class T1, class T2>
class Person;

//类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2> p)
{
    cout <<"类外实现——姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}

template<class T1, class T2>
class Person
{
    //全局函数 类内实现
    friend void printPerson(Person<T1,T2> p)
    {
        cout << "姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
    }

    //全局函数 类外实现
    //加空模板参数列表
    //如果全局函数是类外实现，需要让编译器提前知道这个函数的存在
    friend void printPerson2<>(Person<T1,T2> p);

public:
    Person(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
private:
    T1 m_Name;
    T2 m_Age;
};


//1. 全局函数在类内实现
void test()
{
    Person<string, int>p("Tom", 20);
    printPerson(p);
}

//2. 全局函数在类外实现
void test2()
{
    Person<string, int>p("Jerry", 20);
    printPerson2(p);
}
类模板案例

案例描述：实现一个通用的数组类，要求如下：

  1. 可以对内置数据类型以及自定义数据类型的数据进行存储
  2. 将数组中的数据存储到堆区
  3. 构造函数中可以传入数组的容量
  4. 提供对应的拷贝构造函数以及operate=防止浅拷贝问题
  5. 提供尾插法和尾删法对数组中的数据进行增加和删除
  6. 可以通过下标的方式访问数组中的元素
  7. 可以获取数组中当前元素个数和数组的容量
MyArray.hpp
#pragma once
#include <iostream>
using namespace std;

template<class T>
class MyArray
{
public:
    MyArray(int capacity)
    {
        this->m_Capacity = capacity;
        this->m_Size = 0;
        this->pAddress = new T[this->m_Capacity];
    }

    //拷贝构造
    MyArray(const MyArray& arr)
    {
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;

        //深拷贝
        this->pAddress = new T[arr.m_Capacity];

        //将arr中的数据都拷贝过来
        for (int i = 0; i < this->m_Size; i++)
        {
            this->pAddress[i] = arr.pAddress[i];
        }
    }

    //operator= 防止浅拷贝
    MyArray& operator=(const MyArray& arr)
    {
        //先判断原来堆区是否有数据，如果有先释放
        if (this->pAddress != NULL)
        {
            delete[] this->pAddress;
            this->pAddress = NULL;
            this->m_Capacity = 0;
            this->m_Size = 0;
        }

        //深拷贝
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        this->pAddress = new T[arr.m_Capacity];
        for (int i = 0; i < this->m_Size; i ++)
        {
            this->pAddress[i] = arr.pAddress[i];
        }
        return *this;
    }

    //尾插法
    void Push_Back(const T & val)
    {
        //判断容量是否等于大小
        if (this->m_Capacity == this->m_Size)
        {
            return;
        }
        this->pAddress[this->m_Size] = val;
        this->m_Size++;
    }

    //尾删法
    void Pop_Back()
    {
        if (this->m_Size == 0)
        {
            return;
        }
        this->m_Size--;
    }

    //通过下标方式访问数组元素
    T& operator[](int index)
    {
        return this->pAddress[index];
    }

    //返回数组容量
    int getCapacity()
    {
        return this->m_Capacity;
    }

    //返回数组大小
    int getSize()
    {
        return this->m_Size;
    }

    ~MyArray()
    {
        if (this->pAddress != NULL)
        {
            delete[] this->pAddress;
        }
    }
private:
    T * pAddress;
};
cqu_shuai
关注
专栏目录
C++ STL入门
m0_62021646的博客
01-21 787
文章目录前言一、vector容器二、set容器三、string四、map容器五、algorithm算法库1.sort()2.next_permutation()和prev_permutation() 前言   STL，英文全称 standard template library，中文可译为标准模板库或者泛型库，其包含有大量的模板类和模板函数，是 C++ 提供的一个基础模板的集合，用于完成诸如输入/输出、数学计算等功能。   从根本上说，STL 是一些容器、算法和其他一些组件的集合，所有容器和算法都是总结了
C++入门之模板（上）与new
Masquerena114514的博客
10-20 2126
讲解了C++中的new和模板中的函数模板与类模板的使用
c++ 模板使用入门
04-09
c++ 模板使用入门 c++ 模板使用介绍 pdf
C++之模板入门
LiangXiay的博客
02-22 747
1.函数模板 在C语言中实现一个加法的函数并不困难。 int add(int x, int y) { return x + y; } 但是很明显，这个函数限定了两个相加的数都是整数，并且其返回值也为整数。但是，如果我们想得到两个双精度浮点数相加的结果呢？那么add函数可能就要写成： int addint(int x, int y) { return x + y; } double adddouble(double x, double y) { return x + y; } 那么，如果我
C++模板初阶探索：解锁泛型编程的钥匙
最新发布
17的博客
09-16 1274
在C++编程的世界里，模板（Templates）是一项强大而灵活的特性，它允许程序员编写与类型无关的代码。这一特性极大地提升了代码的重用性和泛型编程的能力。无论是标准模板库（STL）中的容器和算法，还是我们日常开发中遇到的各种通用数据结构，模板都扮演着举足轻重的角色。通过本文的学习，相信你已经对C++模板有了初步的认识和理解。模板不仅让代码更加灵活和通用，还促进了代码的重用，减少了重复劳动。从函数模板到类模板，再到模板的特化和重载，每一步都展示了C++模板机制的强大与灵活。今天的分享到这里就结束啦！
C++标准模板入门
TY113322的博客
03-03 387
1.函数模板 首先我们来实现一个交换函数，该函数一般用在测试排序算法 通过函数的重载我们可以实现不同类型的交换函数，但是这样子写只要有新类型的出现就需要增加对应的函数。而且代码的可维护性也比较低，一个出错可能所以的重载均出错。 为解决这类问题C++提供了这样一个模具，通过给这个模具不同的类型，来生成具体类型的代码。 函数模板的格式 template<typename T1, typename T2,…,typename Tn> 例如： typename是用来定义模板参数的关键字，也可以使用c
C++模板元编程入门
有求必应，有问必答（只要是我能解决的）
06-15 1621
本文通过介绍C++中的模板元编程，让读者了解到什么是模板元编程、为何使用它以及如何使用C++模板实现元编程。将从C++模板的基础知识说起，逐步深入讲解模板元编程的概念、技术和应用，旨在帮助初学者快速入门并提升C++代码的可重用性、可维护性和可扩展性。
模板
weixin_43867777的博客
10-19 178
一、泛型编程 STL是一种泛型编程。面向对象编程关注的是编程的数据方面，而泛型编程关注的是算法。它们之间的共同点是抽象和创建可重用代码，但它们的理念绝然不同。 泛型编程旨在编写独立于数据类型的代码。在C++中，完成通用程序的工具是模板。当然，模板使得能够按泛型定义函数或类，而STL通过通用算法更进了一步。模板让这一切成为可能，但必须对元素进行仔细地设计。 二、函数模板 1、函数模板概念 函数模板代...
C++入门学习——模板示例代码
06-24
在C++编程语言中，模板是一种强大的特性，它允许我们编写通用代码，以处理不同类型的对象，无需重复编写相似的代码。本篇文章将深入探讨C++模板的基本概念、类型和函数模板，以及模板特化和元编程等高级主题。 首先...
c++入门语法及使用 - c++学习路线（csdn）————程序.pdf
12-01
以下是对C++入门语法和使用路线的详细阐述。 一、C++基础 C++的基础部分主要涵盖基本数据类型、运算符、逻辑循环语句和复合数据类型。 1. 基本数据类型 C++支持多种基本数据类型，包括bool、char、int、float和...
C++资源——课件及其入门等---一本书
04-01
《C++程序设计——指针的使用》 在学习C++编程语言时，掌握指针的使用至关重要。指针是C++中一个独特的概念，它允许我们直接操作内存地址，从而实现更高级别的数据操作和控制。本部分将深入探讨指针的概念、类型、...
c++入门----模板
weixin_44678052的博客
10-02 179
一.为什么要定义模板 当我们定义一个加法函数的时候，可能存在以下几种情况，int+int，int+float，flaot+float等等情况，这时候就需要我们定义多个操作相同的加法函数，这样显然是非常繁琐也是没有必要的。 模板的引入就是为了解决这一问题。该编程方式称为“泛型编程”，它的引入大大简化了程序的代码量，保持了结构的清晰，提高的程序设计的效率。 二. 函数模板的定义 定义如下: t...
C++类模板入门
u010632547的博客
04-20 147
类模板的定义如下 template <class NameType, class AgeType> class Person { public: Person(NameType name, AgeType age) { this->m_Name = name; this->m_Age = age; } ...
c++中函数模板与模板函数的理解
abcmutouqianbi的博客
11-02 291
所谓函数模板，实际上是建立一个通用的函数，其函数返回类型和形参类型不具体指定，用一个虚拟的类型来代表。这和通用函数就称为函数模板在调用时系统会根据实参的类型来取代模板中虚拟类型从而实现里不同函数的功能。 函数模板的声明格式如下： template<typename 参数类型> 返回类型 函数名（模板形参列表） { 函数体 } 或 template<class 参数类型> 返回类型 函数名（模板形参列表） { 函数体 } template是一个关键字，表明声明一个模板。参数类型实际上是
【C++】模板入门
xboll2020的博客
03-23 170
C++模板入门
C++模板入门
ganwenfang的专栏
10-03 131
1.在定义类之前要用template声明类型 2.在定义类方法的时候要先用template 声明类型 3.在定义类对象的时候要指名template的实际类型 4.用new生成对象时也要指明template的类型 一个简单的例子如下：  template &lt;typename T&gt; class student {         public:                 ...
C++模板编程入门
weixin_44705391的博客
05-19 604
1.一个案例引入模板 1.1、模板和泛型编程课程介绍 (1)模板编程是C++的一种高级特性，很常用，很有用，可以说是C++的精髓，是C++被广泛使用的关键 (2)泛型在C++、java、C#等多种语言中都有，是现代编程语言典型特性 (3)本章主要内容：见大纲规划 (4)本章开始不像以前以讲为主，而是以写代码和实践为主，在实践中学为主。因为开始变得抽象起来了 (5)本章开始时不做预设规划，随后面讲课时扩展篇幅。 1.2、案例和传统解决方案 (1)问题：swap函数交换2个数 (2)传统解法：定义重载函数，用引
C++入门指南：面向对象与编程基础
"C++入门指南-v2.4.pdf 是DS小龙哥编写的C++初学者及C语言转C++工程师的学习资料，包含了7个章节的内容，覆盖C++语言基本介绍、开发环境搭建、基础入门、面向对象编程、继承与派生、多态与抽象类以及运算符重载和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值