news 2026/4/21 10:18:33

Day 16 C++提高之模板

作者头像

张小明

前端开发工程师

1.2k 24
文章封面图
Day 16 C++提高之模板

Day 16 C++提高之模板

一、模板的概念

模板就是建立通用的模具，大大提高复用性。例如，生活中的模板：一寸照片的模板、PPT模板、论文模板。

模板特点：通用性很强，但是不能直接使用，只是一个框架，模板不是万能的，需要根据自身内容进行修改

二、函数模板

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

1.函数模板的语法

函数模板的作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表。在使用的时候再具体指定

语法：

template<typename T> 函数的声明或定义

解释：

template----- 声明创建模板，告诉编译器要写模板了

typename----- 表明其后面的符号是一种数据类型，可以用class代替，告诉编译器我的后面是一个通用的东西

T -----通用的数据类型，名称（T）可以替换，通常为大写字母，一般用T

//交换两个整型的函数 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; } //函数模板 template<typename T> //要声明一个模板，告诉编译器T是通用模板，通用的数据类型 void mySwap(T& a, T& b) { T temp = a; a = b; b = temp; } void test01() { int a = 10; int b = 20; //swapInt(a, b);//原来的交换函数 //利用函数模板进行交换 //有两种方式使用函数模板 //1.自动类型推导 //mySwap(a, b);//根据传入的数据自己推导 //2.显示指定类型 mySwap<int>(a, b);//在<>中告知编译器这是什么类型 cout << "a = " << a<< endl; cout << "b = " << b<< endl; /*double c = 1.1; double d = 2.2; swapDouble(c, d); cout << "c = " << c << endl; cout << "d = " << d << endl;*/ }
2.函数模板的注意事项
  • 自动类型推导，必须推导出一致的数据类型 T 才可以使用；
  • 模板必须要确定出 T 的数据类型，才可以使用。
//函数模板的注意事项 template<class T>//typename可以替换成class void mySwap(T& a, T& b) { T temp = a; a = b; b = temp; } //1.自动类型推导，必须要推导出一致的数据类型T才可以使用 void test01() { int a = 10; int b = 20; char c = 'c'; mySwap(a, b);//正确，推导出的T一致 //mySwap(a, c);//错误，推导出的T不一致 cout << "a = " << a << endl; cout << "b = " << b << endl; } //2.模板必须要确定出T的数据类型才可以使用 template<class T> void func() { cout << "func函数的调用" << endl; } void test02() { //func();//错误，不知道T是什么类型 func<int>();//正确，指定了T的类型 }

使用模板时必须要确定出通用数据类型T，并且能够推导出一致的类型

3.函数模板的案例

案例描述：利用函数模板封装一个排序的函数，可以对不同数据类型的数组进行排序；排序规则从大到小，排序算法为选择排序；分别利用char数组和int数组进行测试。

//通用的交换数据的函数模板 template<class T> void mySwap(T &a, T &b) { T temp = a; a = b; b = temp; } template<class T> //排序的算法模板 void mySort(T A[],int len) { //选择排序 for (int i = 0; i < len; i++) { int max = i;//每次认定最大值为开始遍历的这个数 for (int j = i + 1; j < len; j++) { if (A[j] > A[max])//比较每个值与max的值 { max = j;//若现在的大，就更新max的下标，最终的max为当前剩下数组的最大值下标 } } if (max != i)//如果比较出来的最大值的下标不等于当轮的初始最大值，就交换二者的位置 { mySwap(A[max], A[i]); } } } //打印数组的模板 template<class T> void myPrint(T arr[],int len) { for (int i = 0; i < len; i++) { cout << arr[i] << " ";//空格分割，不换行 } cout << endl;//换行 } void test01() { char charArr[] = "bascgdfe";//测试的char数组 //int number = sizeof(charArr) / sizeof(char); //mySort(charArr, number); //myPrint(charArr, number); //测试int数组 int intArr[] = { 7,4,9,2,1,6,8,0,3,5 }; int number = sizeof(intArr) / sizeof(int); mySort(intArr, number); myPrint(intArr, number); }
4.普通函数与函数模板的区别
  • 普通函数调用时可以发生自动类型转换（隐式类型转换）；
  • 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换；如果利用显示指定类型的方式，就可以发生隐式类型转换
//普通函数 int myAdd(int a, int b) { return a + b; } //函数模板 template<class T> T myAdd02(T a, T b) { return a + b; } void test01() { int a = 7; int b = 8; char c = 'c'; //普通函数的调用 //cout << myAdd(a, b) << endl;//15 //cout << myAdd(a, c) << endl;//c发生隐式类型转换，c=99，ASCII码 //函数模板调用 //1.自动类型推导，不会发生隐式类型转换 cout << myAdd02(a, b) << endl;//正确，可以推导出一致类型,15 //cout << myAdd02(a, c) << endl;//报错，因为不可以推导出一致类型 //2.显示指定类型。会发生隐式类型转换 cout << myAdd02<int>(a, c) << endl;//106,正确，指定类型，将c转换成int类型 cout << myAdd02<char>(a, c) << endl;//j,正确，计算之后输出char类型的数据 }

提示：推荐只用显示指定类型的方式调用函数模板，因为可以自己确定通用类型的T是什么数据类型

5.普通函数与函数模板的调用规则

调用规则：

  • 如果函数模板和普通函数都可以实现，优先调用普通函数；
  • 可以通过空模板参数列表来强调函数模板；
  • 函数模板也可以发生重载；
  • 如果函数模板可以产生更好的匹配，优先调用函数模板
//普通函数 void myPrint(int a, int b) { cout << "调用的是普通函数" << endl; } //函数模板 template<class T> void myPrint(T a, T b) { cout << "调用的是函数模板" << endl; } //函数模板的重载 template<class T> void myPrint(T a, T b, T c) { cout << "调用的是重载的函数模板" << endl; } void test01() { int a = 7; int b = 8; myPrint(a, b);//普通函数和函数模板函数名相同时，会优先调用普通函数,这时，普通函数必须实现 //通过空模板的参数列表强制调用函数模板 myPrint<>(a, b); myPrint(a, b, 100);//调用的是重载的函数模板 //如果函数模板产生更好的匹配，优先调用函数模板 char c1 = 'a'; char c2 = 'b'; myPrint(c1, c2);//调用的是函数模板，因为普通函数还要作转换，函数模板不用隐式类型转换 }

提供了函数模板就不要写普通函数了，容易出现二义性

6.模板的局限性

模板的通用性不是万能的，例如

template<class T> void func(T a,T b) { a=b;//如果传入的是两个数组，那么就无法实现赋值操作 } //例2 template<class T> void func(T a,T b) { if(a>b){......}//如果T是Person自定义数据类型，也无法正常进行 }

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

class Person { public: Person(string name, int age) {//赋初值操作 this->m_name = name; this->m_age = age; } string m_name; int m_age; }; //对比两个数据是否相等的一个函数 template<class T> bool myCompare(T &a, T &b) { if (a == b) { return true; } else { return false; } } //提供具体的Person的函数模板重载,template<>告知这是一个重载的函数模板 template<> bool myCompare(Person& a, Person& b) { if (a.m_name == b.m_name && a.m_age == b.m_age) { return true; } else { return false; } } void test01() { int a = 8; int b = 7; bool ret = myCompare(a, b); if (ret) { cout << "a==b" << endl; } else { cout << "a!=b" << endl; } } void test02() { Person p1{ "懒羊羊",10 }; Person p2{ "喜羊羊",13 }; bool ret = myCompare(p1, p2); if (ret) { cout << "p1==p2" << endl; } else { cout << "p1!=p2" << endl; } }

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

三、类模板
1.类模板语法

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

语法：

template<typename T> 类的创建

解释：

  • template — 声明下面要创建一个模板
  • typename —表明后面的符号是一种通用的数据类型，可以用class代替
  • T — 通用的数据类型，名称可以替换，通常为大写字母
template<class NameType,class AgeType>//类中两个属性的类型不一样，所以写两个通用数据类型NameType和AgeType class Person { public: //构造函数中给属性函数赋初值 Person(NameType name, AgeType age) { this->m_Name = name; this->m_Age = age; } void showPerson() { cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl; } //属性值 NameType m_Name;//两个属性的类型不一样，所以写两个通用数据类型NameType和AgeType AgeType m_Age; }; void test01() { Person<string, int> p1("懒羊羊", 10);//<>中表示模板的参数列表 //输出成员信息 p1.showPerson(); }

类模板和函数模板语法很相似，在声明模板template后面紧跟创建一个类，这个类就是类模板

2.类模板与函数模板的区别

区别在于两点：

  • 类模板没有自动类型推导的使用方式
  • 类模板在模板参数列表中可以有默认参数
//在最开始写通用类型的时候，直接指定，(区别2）AgeType=int就可以，下面创建对象时，显示指定类型就可以省略int template<class NameType,class AgeType=int> class Person { public: //构造函数赋初值操作 Person(NameType name, AgeType age) { this->m_Name = name; this->m_Age = age; } //成员函数，显示个人信息 void showPerson() { cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl; } NameType m_Name; AgeType m_Age; }; void test01() { //区别1：类模板没有自动类型推导使用方式 //Person p("懒羊羊",10);//报错，类模板无法使用自动类型推导，必须使用显示指定类型 Person<string, int> p("懒羊羊", 10);//正确，使用显示指定类型 p.showPerson(); //区别2：类模板在模板参数列表中可以有默认参数 Person<string>p1("喜羊羊", 13);//在最开始写通用类型的时候，直接指定，AgeType=int就可以，这里就可以省略int }
3.类模板中成员函数创建时机

类模板中成员函数和普通类中的成员函数创建时机是有区别的：

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才创建
class Person1 { public: void showPerson1() { cout << "showPerson1" << endl; } }; class Person2 { public: void showPerson2() { cout << "showPerson2" << endl; } }; template<class T> class myClass { public: //成员1 T obj; //类模板中的成员函数 void func1() { obj.showPerson1();//这两个成员函数只要不调用就不会创建 } void func2() { obj.showPerson2(); } }; void test01() { myClass<Person1>m; m.func1();//正确，m的类型是Person1，showPerson1就是Person1的成员函数，所以可以调用 m.func2();//报错，因为showPerson2不是Person1的成员函数，不可以调用 }

类模板中的成员函数并不是一开始就创建的，而是在调用的时候才会去创建。

4.类模板对象作函数参数

类模板实例化出对象，向函数传参的方式

一共三种传入方式：

  • 指定传入的类型— 直接显示对象的数据类型
  • 参数模板化— 将对象中的参数变为模板进行传递
  • 整个类模板化— 将这个对象类型模板化进行传递
template<class NameType,class AgeType=int> class Person { public: Person(NameType name, AgeType age) { this->m_Name = name; this->m_Age = age; } void showPerson() { cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl; } NameType m_Name; AgeType m_Age; }; //1.指定传入类型 void printPerson1(Person<string,int> &p) { p.showPerson(); } //2.将参数模板化 template<class NameType,class AgeType> void printPerson2(Person<NameType,AgeType>&p)//将参数列表的类型也模板化 { p.showPerson(); //看编译器推出来的类型是什么类型 cout << "NameType的类型为：" << typeid(NameType).name() << endl; cout << "AgeType的类型为：" << typeid(AgeType).name() << endl; } //3.将整个类模板化 template<class T> void printPerson3(T &p)//将前面的Person这一整个类模板化为T { p.showPerson(); cout << "T的数据类型：" << typeid(T).name() << endl; } void test01() { Person<string, int>p("懒羊羊", 10); printPerson1(p);//1.指定传入类型 Person<string, int>p2("喜羊羊", 13); printPerson2(p2);//2.将参数模板化 Person<string, int>p3("沸羊羊", 13); printPerson3(p3);//3.将整个类模板化 }

一般在实际工作中，最常用的就是第一种，指定传入类型

5.类模板与继承

当类模板碰到继承时，需要注意以下几点：

  • 当子类继承的父类是一个类模板时，子类在声明的时候，需指定出父类中 T（通用数据类型）的类型；如果不指定，编译器无法给子类分配内存。
  • 如果想灵活指定出父类中 T 的类型，子类也需要变为类模板
template<class T> class Base { public: T m; }; //class Son :public Base//报错，缺少类模板base的参数列表 class Son:public Base<int>//这里指定了父类Base的通用类型是int，可以正常继承 { //发生继承时，必须要指定父类的通用数据类型的类型是什么？ //但是一旦指定了，父类的通用类型就只能是int类型了，无法灵活应用 }; //灵活继承应用 template<class T1,class T2> class Son2 :public Base<T2> { public: Son2()//构造函数，会在创建对象时自动调用 { cout << "T1的类型为：" << typeid(T1).name() << endl; cout << "T2的类型为：" << typeid(T2).name() << endl; } T1 obj; }; void test01() { Son s1; Son2<int, char>s2;//第一个int给Son的T1，第二个char给父类Base的T，这里父类中的m就是char类型了 }

如果父类是类模板，子类需要指定出父类中T的数据类型

6.类模板成员函数类外实现

目标：能够掌握类模板中成员函数类外实现

template<class T1,class T2> class Person { public: Person(T1 name, T2 age);//类内实现 //{ // this->m_Name = name; // this->m_Age = age; //} void showPerson();//类内实现,这样是类内实现有下面的内容，没有下面的内容，这里就是类内声明，需要在内外实现 //{ // cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl; //} T1 m_Name; T2 m_Age; }; //成员函数类外实现 template<class T1,class T2>//因为直接写的话，编译器不知道那是通用数据类型，写一下说明 Person<T1,T2>::Person(T1 name, T2 age)//为了体现这是一个类模板，所以将模板的参数列表也加上去<> { //第一个Person是作用域，告知是哪个类的成员函数 this->m_Name = name; this->m_Age = age; cout << "构造函数的调用" << endl; } template<class T1,class T2> void Person<T1, T2>::showPerson()//若不写<>就是一共正常的成员函数类外实现，为了体现是一共类模板，所以加上<> { cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl; } void test01() { Person<string, int> p1("懒羊羊", 10); p1.showPerson(); }
7.类模板分文件编写

目标：掌握类模板成员函数分文件编写，产生的问题以及解决方式

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

解决：

  • 直接包含.cpp源文件
  • 将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是C++编程者约定的名称，并不是强制的

C++编写时，通常把每个类单独写在一个文件中，.h文件中写类的声明以及成员函数的声明，然后再.CPP文件中写成员函数具体的实现

第一种解决办法：将原先的包含头文件.h，改为包含.cpp文件

#include<iostream> using namespace std; #include<string> //1.直接包含.cpp文件 #include"person.cpp" void test01() { Person<string, int>p1("懒羊羊", 10); p1.showPerson(); }

第二种解决办法：.h和.cpp文件的内容写在一个文件中，然后将.h文件后缀名改为.hpp文件，然后包含.hpp文件

//2.包含.hpp文件 #include"person.hpp" void test01() { Person<string, int>p1("懒羊羊", 10); p1.showPerson(); } //person.hpp文件的代码 #pragma once #include<iostream> using namespace std; #include<string> 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; }

因为类模板的成员函数创建时机是调用它时。主流的解决办法是第二种方式，将类模板成员函数的声明和实现写在一起，并将.h文件的后缀名改为.hpp，然后不需要源文件.cpp

8.类模板与友元

目标：掌握类模板配合友元函数的类内和类外实现

  • 全局函数的类内实现 – 直接在类内声明友元即可
  • 全局函数的类外实现 – 需要提前让编译器知道全局函数的存在
//1.全局函数类内实现 template<class T1,class T2> class Person { //全局函数，类内实现 friend void printPerson(Person<T1,T2> p)//参数模板化传参 { cout << "姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl; } public: Person(T1 name, T2 age) { this->m_Name = name; this->m_Age = age; } private: T1 m_Name; T2 m_Age; }; //全局函数在类内实现 void test01() { Person<string, int>p1("懒羊羊", 10); printPerson(p1); } //2.全局函数类外实现 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; } //通过全局函数打印Person的信息 template<class T1,class T2> class Person { //全局函数，类外实现 //friend void printPerson2(Person<T1, T2>p);//这是一个普通函数的声明，所以加一个空模板的<>参数列表 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; }; //全局函数在类内实现 void test01() { //全局函数在类外实现测试 printPerson2(p1); }

建议写全局函数类内实现，用法简单，编译器可以直接识别。不建议类外实现，稍微复杂

版权声明: 本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！
网站建设 2026/4/19 14:47:36

原神自动化助手完全使用手册：从入门到精通的全流程指南

原神自动化助手完全使用手册&#xff1a;从入门到精通的全流程指南 【免费下载链接】better-genshin-impact &#x1f368;BetterGI 更好的原神 - 自动拾取 | 自动剧情 | 全自动钓鱼(AI) | 全自动七圣召唤 | 自动伐木 | 自动派遣 | 一键强化 - UI Automation Testing Tools Fo…

作者头像 李华
网站建设 2026/4/19 9:05:04

微信多设备登录终极解决方案：WeChatPad平板模式

微信多设备登录终极解决方案&#xff1a;WeChatPad平板模式 【免费下载链接】WeChatPad 强制使用微信平板模式 项目地址: https://gitcode.com/gh_mirrors/we/WeChatPad 还在为微信的单设备登录限制而烦恼吗&#xff1f;想要在手机和平板上同时登录微信&#xff0c;却总…

作者头像 李华
网站建设 2026/4/17 7:42:04

【Java面试官VS谢飞机】Spring Boot+微服务+AI架构高频考点全解析

面试现场&#xff1a;严肃面试官 vs 搞笑程序员谢飞机 面试官&#xff1a;欢迎来到字节跳动Java高级工程师岗位终面。我们开始吧。&#x1f31f; 第一轮&#xff1a;Spring Boot 与 Web 基础面试官&#xff1a;Spring Boot 自动装配的原理是什么&#xff1f;你怎么理解 SpringB…

作者头像 李华