《C++ SYNTAX》第9章 模板

已于 2022-03-17 15:39:08 修改
阅读量100 收藏
点赞数
分类专栏： C++ 文章标签： c++
于 2022-01-05 10:50:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dasdkhaksd/article/details/122318037
版权

第9章 模板

(9.1) 函数模板

如果要编写一个对任意数据类型都适用的交换函数，根据这之前所掌握的内容来看就只能根据数据类型的不同进行分类编写：

void swapInt(int &a,int &b) //交换两个整型
{
    int temp = a;
    a = b;
    b = temp;
}

void swapDouble(double &a,double &b) //交换两个实型
{
    double temp = a;
    a = b;
    b = temp;
}

...

这个时候就可以用函数模板来简化问题：

#include<iostream>
using namespace std;

//typename关键字可以替换成class，两者无本质区别
//但是函数模板习惯上用typename，类模板习惯上用class
template<typename T> //声明模板，T是通用数据类型，下面紧跟函数
void mySwap(T &a,T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

int main()
{
    int a = 10;
    int b = 20;
    mySwap(a,b); //自动类型推导(必须推导出一致的数据类型T才可以使用)
    mySwap<int>(a,b); //显示指定类型
    system("pause");
    return 0;
}

例：用函数模板封装一个选择排序函数，可以对不同类型的数据进行从大到小排序，并分别用char数组和int数组进行测试。

#include<iostream>
using namespace std;

template<typename T>
void selectSort(T arr[],int len) //传入数组和数组长度
{
    for(int i = 0;i < len;i++)
    {
        int maxIndex = i; //假定最大值的下标
        for(int j = i + 1;j < len;j++)
        {
			//假定的最大值比遍历出的值要小，此时最大值下标变为j
            if(arr[maxIndex] < arr[j])
            {
                maxIndex = j;
            }
        }
        if(maxIndex != i)
        {
            T temp = arr[maxIndex];
            arr[maxIndex] = arr[i];
            arr[i] = temp;
        }
    }
}

int main()
{
    char charArr[] = "badcfe";
    int intArr[] = {1,3,5,2,4};
    int charLen = sizeof(charArr)/sizeof(char);
    int intLen = sizeof(intArr)/sizeof(int);
    selectSort(charArr,charLen);
    selectSort(intArr,intLen);
    system("pause");
    return 0;
}

当函数模板的参数列表为空时，必须要随意地显示指定一个类型：

#include<iostream>
using namespace std;

template<typename T>
void func(){}

int main()
{
    //func(); //会报错，此时编译器无法进行类型推导
    func<int>(); //随便写一种数据类型就可以调用了
    system("pause");
    return 0;
}

普通函数在调用时可以发生隐式类型转换，函数模板在用自定义类型推导时不可以发生隐式类型转换，但是当函数模板用显示指定类型时，可以发生隐式类型转换：

#include<iostream>
using namespace std;

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

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

int main()
{
    int a = 10;
    char b = 'a'; //ASCII码为97
    cout << myAdd2(a,b) << endl; //107，普通函数会将字符a隐式转换成其ASCII码进行相加运算
    //cout << myAdd1(a,b) << endl; //会报错,函数模板在自动类型推导时不能进行隐式转换
    cout << myAdd1<int>(a,b) << endl; //107，函数模板在有指定类型时可以发生隐式类型转换
    system("pause");
    return 0;
}

如果用函数模板和普通函数都可以实现，优先调用普通函数。可以通过空模板参数列表来强制调用函数模板，函数模板也可以发生重载，如果函数模板可以产生更好的匹配，编译器优先调用函数模板。

#include<iostream>
using namespace std;

void func(int a,int b){}

template<typename T>
void func(T a,T b){}

template<typename T>
void func(T a,T b,T c){}

int main()
{
    int a = 10;
    int b = 20;
    func(a,b); //调用普通函数
    func<>(a,b); //通过空模板参数列表强制调用函数模板
    func(a,b,30); //函数模板也可以发生重载
    char c = 'a';
    char d = 'b';
    func(c,d); //调用函数模板，因为不用发生隐式转换，有更好的匹配
    system("pause");
    return 0;
}

模板的通用性并不是万能的，比如==运算符在函数模板中可以比较大多数数据类型，但是不能比较自定义数据类型。C++为了解决这一问题，除了运算符重载外，还提供了模板的重载，可以为这些特定的数据类型提供具体化模板。

class Person
{
public:
    int m_Age;
public:
    Person(int age)
    {
        this->m_Age = age;
    }
};

//模板比较函数(可以比较除了自定义数据类型之外的其他类型)
template<typename T>
bool myCompare(T &a,T &b)
{
    return a == b;
}

//模板的重载(添加自定义数据类型比较功能)
template<> bool myCompare(Person &p1,Person &p2)
{
    if(p1.m_Age == p2.m_Age)
    {
        return true;
    }
    else
    {
        return false;
    }
}

(9.2) 类模板

#include<iostream>
#include<string>
using namespace std;

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

int main()
{
    Person<int> p(18);
    system("pause");
    return 0;
}

类模板没有自动类型推导，并且类模板在模板参数列表中可以有默认参数：

#include<iostream>
#include<string>
using namespace std;

template<class NameType,class AgeType = int> //AgeType有默认参数int
class Person
{
public:
    NameType m_Name;
    AgeType m_Age;
public:
    Person(NameType name,AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
};

int main()
{
    Person<string> p1("Tom",10);
    Person<string,double> p2("Tom",10.0); //如果传了默认参数位置的参数，那么就用传入的数据类型
    system("pause");
    return 0;
}

类模板对象做函数参数的三种传入方式：

//指定传入类型(常用)
void func1(Person<string,int> &p){}
//参数模板化
template<class NameType,class AgeType>
void func2(Person<NameType,AgeType> &p){}
//整个类模板化
template<class Person>
void func3(Person &p){}

子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中属性的类型，如果不指定，编译器无法给子类分配内存。如果想灵活指定出父类中属性的类型，子类也需要变为类模板：

#include<iostream>
using namespace std;

template<class AgeType>
class Father
{
public:
    AgeType m_Age;
};

//class Son1 : public Father{}; //错误方式，必须要知道父类中的AgeType类型才能继承给子类
class Son1 : public Father<int>{}; //正确方式，但是父类中的m_Age的数据类型就只能是int了

//如果想要灵活指定出父类中T的类型，子类也需要变为类模板
template<class AgeType1,class AgeType2>
class Son2 : public Father<AgeType1>
{
    AgeType2 m_Age;
};

int main()
{
    Son2<int,double> s; //指定父类中的AgeType1为int型，子类中的AgeType2为double型
    system("pause");
    return 0;
}

类模板成员函数在类外实现的写法：

template<class NameType,class AgeType>
class Person
{
public:
    NameType m_Name;
    AgeType m_Age;
public:
    Person(NameType name,AgeType age); //构造函数类内声明
    void showPerson(); //普通成员函数类内声明
};

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

//普通成员函数类外实现
template<class NameType,class AgeType>
void Person<NameType,AgeType>::showPerson()
{
    cout << this->m_Name << this->m_Age <<endl;
}

类模板在分文件编写时，类模板中的成员函数的创建时机是在调用阶段，这就导致了在分文件编写时链接不到，有两种解决方法：

//解决方法一：在主函数中直接包含.cpp源文件

//person.h
#pragma once //防止头文件重复包含
#include<iostream>
using namespace std;
template<class AgeType>
class Person
{
public:
    AgeType m_Age;
public:
    Person(AgeType age);
};

//person.cpp
#include"person.h"
template<class AgeType>
Person<AgeType>::Person(AgeType age)
{
    this->m_Age = age;
}

//main.cpp
#include<iostream>
#include"person.cpp" //直接包含.cpp源文件
using namespace std;
int main()
{
    Person<int> p(18);
    system("pause");
    return 0;
}

//解决方法二：将声明和实现写到同一个文件中，并更改后缀名为.hpp(hpp是约定名称，并不是强制规定)

//person.hpp
#pragma once
#include<iostream>
using namespace std;
template<class AgeType>
class Person
{
public:
    AgeType m_Age;
public:
    Person(AgeType age);
};
template<class AgeType>
Person<AgeType>::Person(AgeType age)
{
    this->m_Age = age;
}

//main.cpp
#include<iostream>
#include"person.hpp" //包含.hpp源文件
using namespace std;
int main()
{
    Person<int> p(18);
    system("pause");
    return 0;
}

类模板也可以结合友元技术，接下来介绍一下全局函数模板做友元的类外实现和全局函数模板做友元的类内实现的写法：

//全局函数模板做友元的类外实现
#include<iostream>
#include<string>
using namespace std;

template<class AgeType> //提前告诉编译器Person类模板的存在
class Person;

//全局函数模板类外实现(必须写在声明的前面)
template<class AgeType>
void showPerson(Person<AgeType> p)
{
    cout << p.m_Age << endl;
}

template<class AgeType>
class Person
{
    friend void showPerson<>(Person<AgeType> p); //全局函数模板类内声明(记得加上<>)
private:
    AgeType m_Age;
public:
    Person(AgeType age)
    {
        this->m_Age = age;
    }
};

int main()
{
    Person<int> p(18);
    showPerson(p);
    system("pause");
    return 0;
}

//全局函数模板做友元的类内实现
#include<iostream>
#include<string>
using namespace std;

template<class AgeType>
class Person
{
    friend void showPerson(Person<AgeType> p) //全局函数模板类内实现
    {
        cout << p.m_Age << endl;
    }
private:
    AgeType m_Age;
public:
    Person(AgeType age)
    {
        this->m_Age = age;
    }
};

int main()
{
    Person<int> p(18);
    showPerson(p);
    system("pause");
    return 0;
}

《 C + +   S Y N T A X 》 系 列 博 客 创 作 参 考 资 料 来 源 《C++\ SYNTAX》系列博客创作参考资料来源 《C++ SYNTAX》系列博客创作参考资料来源

  1. 《黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难》@黑马程序员.https://www.bilibili.com.

博 客 创 作 ： A i d e n   L e e 博客创作：Aiden\ Lee 博客创作：Aiden Lee
特别声明：文章仅供学习参考，转载请注明出处，严禁盗用！

wibibaboo
关注
专栏目录
C++类模板
Anna_L的博客
10-26 1369
C++模板类详解学习
c++ syntax english edition
07-20
"C++ Syntax English Edition"教程显然是针对英语环境的学习者，旨在帮助他们理解和掌握C++的基本语法和编程概念。 1. **C++简介**: C++不仅继承了C语言的简洁和效率，还引入了类、对象和继承等面向对象编程的概念...
《C++ SYNTAX》第10章 容器
Aiden Lee's blog
01-05 691
第10章 容器(10.1) STL概述(10.2) string容器(10.3) vector容器(14.4) deque容器(14.5) stack容器(14.6) queue容器(14.7) list容器(14.8) set&multiset容器(14.9) map&multimap容器 (10.1) STL概述 长期以来，软件界一直希望建立一种可重复利用的东西，C++的面向对象和泛型编程思想，目的就是为了提高复用性。大多数情况下，数据结构和算法未能有一套标准，导致被迫从事大量重复的工
C++ Function Templates (函数模板)
既然选择了远方 便只顾风雨兼程 - 永强
03-11 2129
C++ Function Templates (函数模板)
C++模板（第二版）笔记之第八章：编译期编程
喜欢打篮球的普通人
01-01 607
IsPrime模板将结果存储在其成员 value 中。为了计算出模板参数是不是质数， 它实例化了DoIsPrime模板， 这个模板会被递归展开， 以计算 p 除以 p/2 和 2 之间的数之后是否会有余数。C++14则没有，但是要求各个计算步骤都能在编译期进行，此外堆内存分配和异常抛出都不被支持。C++模板的原始递归模板可以用来“计算一个程序的结果”由于 9%3 == 0， 因此它将返回 false；的定义通常都只能包含一个 return 语句。
c++ primer plus 第十四章 C++中的代码重用
weixin_59141600的博客
10-14 601
c++ 中的代码重用
【C++ Primer Plus】第14章 C++中的代码重用
chaiky的博客
10-19 1696
第14章 C++中的代码重用。has-a关系。 包含对象成员的类。 模板类valarray。 私有和保护继承。 多重继承。 虚基类。 创建类模板。 使用类模板。 模板的具体化。
Essential C++ Lippman 第1章 C++编程基础 摘录
weixin_47955824的博客
11-14 802
一些基础数据类型； 算术运算符； 条件分支和循环控制语句； 一些复合类型； 一套标准的、通用的抽象化库；
Templates in C++ - C++ 中的模板
既然选择了远方 便只顾风雨兼程 - 永强
02-23 398
Templates in C++ - C++ 中的模板 Templates are used to prevent us from writing the same function or class separately for different data types. We normally use templates in large programs where we have to define the same function or class for different data type
【C++基础】第9章：序列与关联容器
qq_60225495的博客
10-31 2989
序列与关联容器1 容器概述1.1 容器：一种特殊的类型，其对象可以放置其它类型的对象（元素）1.1.1 需要支持的操作：对象的添加、删除、索引、遍历1.1.2 有多种算法可以实现容器，每种方法各有利弊1.2 容器分类1.2.1 序列容器：其中的对象有序排列，使用整数值进行索引1.2.2 关联容器：其中的对象顺序并不重要，使用键进行索引1.2.3 适配器：调整原有容器的行为，使得其对外展现出新的类型、接口或返回新的元素1.2.4 生成器：构造元素序列1.3 迭代器：用于指定容器中的一段区间，以执行遍历、删除等
c_syntax_v102.rar_C++
09-23
了解这些基础知识是编写C++程序的第一步。 2. 函数：C++中的函数用于组织代码，实现特定功能。函数可以有参数，也可以返回值。理解函数的定义、调用和重载对于编写复用性高的代码至关重要。 3. 类与对象：C++的...
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 170
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
【C语言】数据类型和变量
最新发布
2302_76713442的博客
10-06 1031
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 981
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C - Separated Lunch
m0_74304371的博客
10-05 274
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
【C语言】字符函数和字符串函数(1)
hdxbufcbjuhg的博客
09-28 1723
str是\0了，循环是照常结束，但是str还要++一次，str就指向\0后面了，根据我们前面的分析就是错误的，所以这里只能把str自增的语句写在循环体内，当然，如果是拷贝字符串则不用担心这一点，可以放心把自增写在循环判断条件中。原型解析：strcpy的第一个参数是我们拷贝字符串的目的地的首地址，也就是接收拷贝的数组的首元素地址，第二个参数是我们拷贝字符串的源字符串的首地址，它的返回值就是接收拷贝的目标空间的初始地址。strcmp的作用就是帮我们比较两个字符串的大小，那么比较的依据是什么呢？
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
m0_59237910的博客
10-01 413
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
【C++】类与对象基础概念解析
A Charmer 的博客
10-03 1384
在 C++ 编程中，类与对象是核心概念之一，它们为程序设计提供了一种强大而灵活的方式来组织代码和管理数据。理解类与对象的基础概念对于掌握 C++ 编程至关重要。
C++14语法速查指南(第二版)
"C++ 14 Quick Syntax Reference" 是一本由Apress出版的第二版指南，专注于介绍更新后的C++ 14编程语言的语法。本书以简洁、直截了当的方式呈现C++ 14的关键语法，适用于程序员作为快速参考手册。书中避免了技术术语...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值