C++模板详解

已于 2022-03-30 10:02:24 修改
阅读量854 收藏 5
点赞数 2
分类专栏： C++STL 文章标签： c++
于 2021-09-27 09:33:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45605541/article/details/120501966
版权

文章目录

1. 模板概念

模板提供了一种通用的方法来开发可重用的代码，即可创建参数化的C++类型。通俗来讲，模板就是建立通用的模具，大大提高复用性。

模板的特点：

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

模板的分类：

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

2. 函数模板

2.1 函数模板作用

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

2.2 语法

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

template – 声明创建模板

typename – 表明其后面的符号是一种数据类型，可以用class代替

T – 通用的数据类型，名称可以替换，通常为大写字母

2.3 举例

#include<iostream>
using namespace std;
//函数模板：实现两个数交换的函数
template<typename T> //声明一个模板，告诉编译器T是一个通用的数据类型
void mySwap(T &a,T &b){
    T temp=a;
    a=b;
    b=temp;
}
void test01(){
    //函数模板实现有两种方法
    //1.自动类型推导
    int a=10;
    int b=20;
    cout<<"a="<<a<<" "<<"b="<<b<<endl;
    mySwap(a,b);
    cout<<"交换后："<<endl;
    cout<<"a="<<a<<" "<<"b="<<b<<endl;
    cout<<endl;
    //2.显示指定类型
    double c=3.2;
    double d=4.5;
    cout<<"c="<<c<<" "<<"d="<<d<<endl;
    mySwap<double>(c,d);
    cout<<"交换后："<<endl;
    cout<<"c="<<c<<" "<<"d="<<d<<endl;
}
int main(){
    test01();
    system("pause");
    return 0;
}

在这里插入图片描述

2.4 注意事项

  1. 自动类型推导必须推导出一致的数据类型T，才可以使用

  2. 模板必须要确定出T的数据类型，才可以使用

    举例：

    #include<iostream>
using namespace std;
template<typename T>
void func(){
    cout<<"func() 调用"<<endl;
}
void test01(){
    //func();//没有与参数列表匹配的 函数模板 "func" 实例 
    func<int>();//应显示指定类型
}
int main(){
    test01();
    system("pause");
    return 0;
}

    在这里插入图片描述

小结：

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

2.5 普通函数与函数模板的区别

  1. 普通函数调用时可以发生自动类型转换（隐式类型转换）
  2. 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
  3. 函数模板用显示指定类型，可以发生隐式类型转换

举例：

#include<iostream>
using namespace std;
int myAdd01(int a,int b){ //普通函数
    return a+b;
}
template<typename T> //函数模板
T myAdd02(T a,T b){
    return a+b;
}
void test01(){
    int a=10;
    char b='c';
    cout<<"普通函数发生隐式类型转换："<<myAdd01(a,b)<<endl; //普通函数：变量b发生隐式类型转换,将字符型隐式地转化为整型
    //cout<<myAdd02(a,b)<<endl; //函数模板中的自动类型推导：报错：没有与参数列表匹配的 函数模板
    cout<<"函数模板显示指定类型中发生了隐式类型转换："<<myAdd02<int>(a,b)<<endl; //函数模板中的显示指定类型：发生隐式类型转换
}
int main(){
    test01();
    system("pause");
    return 0;
}

在这里插入图片描述

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

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

举例：

#include<iostream>
using namespace std;
void myPrint(int a,int b){
    cout<<"调用普通函数"<<endl;
}
template<typename T>
void myPrint(T a,T b){
    cout<<"调用函数模板"<<endl;
}
template<typename T>
void myPrint(T a,T b,T c){
    cout<<"调用重载的函数模板"<<endl;
}
void test01(){
    int a=10;
    int b=20;
    myPrint(a,b);//1.如果函数模板和普通函数都可以实现，优先调用普通函数
    myPrint<>(a,b);//2.通过空模板参数列表来强制调用函数模板
    myPrint(a,b,100);//3.函数模板也可以发生重载
    char c1='a';
    char c2='b';
    myPrint(c1,c2);//4.如果函数模板可以产生更好的匹配，优先调用函数模板
    //编译器认为将c1和c2推导出T为char型，比调用普通函数进行强制类型转换简单
}
int main(){
    test01();
    system("pause");
    return 0;
}

在这里插入图片描述

小结：

既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性。

2. 模板特化

2.1 模板的局限性

模板的通用性并不是万能的。

比如：

template<typename T>
T sum(T data[],int nSize){
    T sum=0;
    for (int i = 0; i < nSize; i++)
    {
        sum+=data[i];
    }
    return sum;
}

上述代码具有一定的局限性，那就是它只能对数组元素求和，假如想要实现对链表、集合等元素的求和，它就不能实现了，这也是STL的思维方式想要解决的问题。为了解决这一问题，我们提出了模板特化的概念。

2.2 模板特化的概念

概念：

在实例化模板时，对特定类型的实参进行特殊处理，即实例化一个特殊的版本。

举例：

#include<iostream>
#include<string>
using namespace std;
//对比两个数据是否相等的函数
class Person{
public:
    string m_name;
    int m_age;
public:
    Person(string name,int age){
        m_name=name;
        m_age=age;
    }
};
template<typename T>
bool myCompare(T &a,T &b){
    if (a==b)
    {
        return true;
    }
    else{
        return false;
    }
}
//利用模板特化实现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;
    }  
}
void test01(){
    int a=10;
    int b=20;
    bool ret=myCompare(a,b);
    if (ret)
    {
        cout<<"a=b"<<endl;
    }
    else{
        cout<<"a!=b"<<endl;
    }  
}
void test02(){
    Person p1("Tom",20);
    Person p2("Tom",30);
    bool ret=myCompare(p1,p2);
    if (ret)
    {
        cout<<"p1=p2"<<endl;
    }
    else{
        cout<<"p1!=p2"<<endl;
    }   
}
int main(){
    test01();
    test02();
    system("pause");
    return 0;
}

在这里插入图片描述

小结：

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

3. 类模板

3.1 类模板概述

类模板作用：

建立一个通用类，类中成员的数据类型可以不具体指定，用一个虚拟的类型来代表，在创建对象时再去指定类中成员的数据类型。

语法：

template<class T>
类

template – 声明创建模板

class – 表明其后面的符号是一种数据类型，可以用typename代替

T – 通用的数据类型，名称可以替换，通常为大写字母

举例：

#include<iostream>
#include<string>
using namespace std;
template<class NameType,class AgeType>
class Person{
public:
    NameType m_name;
    AgeType m_age;
public:
    Person(NameType name,AgeType age){
        m_name=name;
        m_age=age;
    }
    void showPerson(){
        cout<<"name:"<<m_name<<" "<<"age:"<<m_age<<endl;
    }
};
void test01(){
    Person<string,int> p1("Tom",20);//在将类模板实例化时，必须显式定义具体类型，编译器无法为我们自动推导
    p1.showPerson();
}
int main(){
    test01();
    system("pause");
    return 0;
}

在这里插入图片描述

小结：

  1. 在将类模板实例化时，必须显式定义具体类型，编译器无法为我们自动推导。
  2. 类模板和函数模板语法相似，在声明模板template后面加类，即为类模板。

3.2 类模板和函数模板的区别

区别：

  1. 类模板没有自动类型推导的使用方式
  2. 类模板在模板参数列表中可以有默认参数

举例：

#include<iostream>
#include<string>
using namespace std;
template<class NameType,class AgeType=int>//类模板在模板参数列表中可以有默认参数，默认为int类型
class Person{
public:
    NameType m_Name;
    AgeType m_Age;
public:
    Person(NameType name,AgeType age){
        m_Name=name;
        m_Age=age;
    }
    void showPerson(){
        cout<<"name:"<<m_Name<<" "<<"age:"<<m_Age<<endl;
    }
};
void test01(){
    //Person p1("Tom",20);//报错，因为类模板没有自动类型推导的使用方式
    Person<string,int> p1("Tom",20);
    p1.showPerson();
    Person<string> p2("Lisa",24);//因为m_age的默认类型为int，故这里不用显示指定参数类型
    p2.showPerson();
}
int main(){
    test01();
    system("pause");
    return 0;
}

在这里插入图片描述

3.3 类模板中成员函数的创建时机

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

  1. 普通类中的成员函数一开始就可以创建
  2. 类模板中的成员函数在调用时才创建

举例：

#include<iostream>
using namespace std;
class Person1{
public:
    void showPerson1(){
        cout<<"Person1 show"<<endl;
    }
};
class Person2{
public:
    void showPerson2(){
        cout<<"Person2 show"<<endl;
    }
};
template<class T>
class MyClass{
public:
    T obj;
public:
    void func1(){
        obj.showPerson1();
    }    
    void func2(){
        obj.showPerson2();
    }    
};
void test01(){
    MyClass<Person1> m;
    m.func1();
    //m.func2();//报错，Person1中没有函数showPerson2。因为类模板中的成员函数在调用时才创建
    //给类模板传入Person1类型的对象，类模板确定了T为Person1时，才创建自己的成员函数
}
int main(){
    test01();
    system("pause");
    return 0;
}

在这里插入图片描述

3.4 类模板对象做函数参数

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

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

举例：

#include<iostream>
#include<string>
using namespace std;
template<class T1,class T2>
class Person{
public:
    T1 m_name;
    T2 m_age;
    Person(T1 name,T2 age){
        m_name=name;
        m_age=age;
    }
    void showPerson(){
        cout<<"name:"<<m_name<<" "<<"age:"<<m_age<<endl;
    }
};
//1.传入指定类型
void printPerson1(Person<string,int> &p){
    p.showPerson();
}
void test01(){
    Person<string,int> p1("Tom",20);
    printPerson1(p1);
}
//2.参数模板化
template<typename T1,typename T2>
void printPerson2(Person<T1,T2>&p){
    p.showPerson();
}
void test02(){
    Person<string,int>p2("Lisa",24);
    printPerson2(p2);
}
//3.整个类模板化
template<typename T>
void printPerson3(T &p){
    p.showPerson();
}
void test03(){
    Person<string,int>p3("David",30);
    printPerson3(p3);
}
int main(){
    test01();
    test02();
    test03();
    system("pause");
    return 0;
}

在这里插入图片描述

3.5 类模板与继承

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

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

举例：

#include<iostream>
#include<string>
using namespace std;
template<class T>
class Base{
    T m;
};
class Son1:public Base<int>{//指定出父类中T的类型

}; 
void test01(){
    Son1 s1;
}
template<class T1,class T2>
class Son2:public Base<T2>{//想灵活指定出父类中T的类型，子类也需变为类模板
    T1 obj;
public:
    void showSon2(){
        cout<<"T1的数据类型为："<<typeid(T1).name()<<endl;
        cout<<"T2的数据类型为："<<typeid(T2).name()<<endl;
    }
};
void test02(){
    Son2<int,char> s2;//将int传给T1，应用于Son2类；将char传给T2，应用于Base类
    s2.showSon2();
}
int main(){
    test01();
    test02();
    system("pause");
    return 0;
}

在这里插入图片描述

小结：

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

3.6 类模板中成员函数的类外实现

#include<iostream>
#include<string>
using namespace std;
template<class T1,class T2>
class Person{
public:
    T1 m_Name;
    T2 m_Age;
    Person(T1 name,T2 age);
    void showPerson();
};
//构造函数的类外实现
template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age){
    m_Name=name; 
    m_Age=age;
}
//成员函数的类外实现
template<class T1,class T2>
void Person<T1,T2>::showPerson(){
        cout<<"name："<<m_Name<<endl;
        cout<<"age:"<<m_Age<<endl;
}
void test01(){
    Person<string,int> p("Tom",20);
    p.showPerson();
}
int main(){
    test01();
    system("pause");
    return 0;
}

在这里插入图片描述

小结：

类模板中的成员函数类外实现时，需要加上模板参数列表。

3.7 类模板分文件编写

问题提出：

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

解决方式：

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

举例：

解决方式1：直接包含.cpp源文件

Person.h：

#pragma once
#include<iostream>
using namespace std;
template<class T1,class T2>
class Person{

    T1 m_Name;
    T2 m_Age;
public:
    Person(T1 name,T2 age);
    void showPerson();
};

Person.cpp:

#include<iostream>
#include"Person.h"
using namespace std;
template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age){
    m_Name=name;
    m_Age=age;
}
template<class T1,class T2>
void Person<T1,T2>::showPerson(){
    cout<<"name:"<<m_Name<<" "<<"age:"<<m_Age<<endl;
}

Demo12.cpp:

#include<iostream>
using namespace std;
#include"Person.cpp"
void test01(){
    Person<string,int> p("Tom",20);
    p.showPerson();
}
int main(){
    test01();
    system("pause");
    return 0;
}

在这里插入图片描述

解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp：

Person.hpp:

#pragma once
#include<iostream>
using namespace std;
template<class T1,class T2>
class Person{

    T1 m_Name;
    T2 m_Age;
public:
    Person(T1 name,T2 age);
    void showPerson();
};
template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age){
    m_Name=name;
    m_Age=age;
}
template<class T1,class T2>
void Person<T1,T2>::showPerson(){
    cout<<"name:"<<m_Name<<" "<<"age:"<<m_Age<<endl;
}

Demo12.cpp:

#include<iostream>
using namespace std;
#include"Person.hpp"
void test01(){
    Person<string,int> p("Tom",20);
    p.showPerson();
}
int main(){
    test01();
    system("pause");
    return 0;
}

在这里插入图片描述

3.8 类模板与友元

全局函数类内实现：

直接在类中声明友元即可。

#include<iostream>
using namespace std;
template<class T1,class T2>
class Person{
    //全局函数类内实现
    friend void printPerson(Person<T1,T2> p){
        cout<<"姓名："<<p.m_name<<" 年龄："<<p.m_age<<endl;
    }
    string m_name;
    int m_age;
public:
    Person(T1 name,T2 age){
        m_name=name;
        m_age=age;
    }
};
void test01(){
    Person<string,int> p("tom",20);
    printPerson(p);
}
int main(){
    test01();
    system("pause");
    return 0;
}

在这里插入图片描述

全局函数类外实现：

需要提前让编译器知道全局函数的存在。

#include<iostream>
using namespace std;
template<class T1,class T2>
class Person;//提前告知编译器类模板的存在
template<class T1,class T2>//提前让编译器知道全局函数的存在
void printPerson(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);
    string m_name;
    int m_age;
public:
    Person(T1 name,T2 age){
        m_name=name;
        m_age=age;
    }
};
void test01(){
    Person<string,int> p("tom",20);
    printPerson(p);
}
int main(){
    test01();
    system("pause");
    return 0;
}

在这里插入图片描述

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

参考视频：https://www.bilibili.com/video/BV1et411b73Z?p=167

月光晒了很凉快
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++模板详解（函数模板、类模板）
bang___bang_的博客
05-13 2156
本文详细讲解模板：函数模板，类模板，模板特化，非特性模板参数，详细得当适合初学者学习。
C++之模板编程
u010378559的博客
05-04 1828
C++模板编程总结
C++模板（template）详解
最新发布
2301_81261654的博客
03-09 2701
原因是在链接过程中，编译器找不到模板函数的定义，因为在使用模板时，.h文件中的模板的声明知晓了模板参数的类型，但在.cpp文件中的模版不知道，所以.cpp中模板的定义没法实例化,也就没法在编译阶段生成一份经过实例化的具体的代码，这将导致程序在链接阶段找不到模板函数的实现而报链接错误。这样一来，在调用Add函数的时候，其本质上是调用了上面的经过实例化的模板函数，这样做的好处就是，程序员就可以不用对每一种数据类型都去实现对应的函数，大大提高了效率，而且只实现这么一份通用的模板函数可以使其更易于维护。
C++编程语言中模板（template）介绍
liitdar的博客
06-05 6030
本文主要介绍 C++ 编程语言中模板（template）的相关知识，同时通过示例代码介绍模板的使用方法。 1 概述 1.1What 泛型编程是一种代码编写方式，通过使用泛型编程，可以编写出独立于任何特定类型的代码。 模板是泛型编程的基础，是创建泛型函数或类的蓝图（公式）。 C++ 的 STL 容器及其迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。每个容器都有一个单一的定义，比如 vector，我们可以定义许多包含不同类型元素的 vector，比如：vector <int>.
C++模板
weixin_63246738的博客
05-19 5381
c++的模板
C++之模板
m0_74893211的博客
06-22 4381
C++泛型编程和STL技术详细讲解。
C++——模板（超详细的模板解析）
热门推荐
JAN6055的博客
04-01 5万+
超详细的C++模板知识列表，持续维护。
【C++】—— 模板介绍
m0_56069910的博客
06-08 1985
模板的详细介绍
详解C++ 模板编程
12-16
类型模板包括函数模板和类模板，基本上是C++开发人员接触模板编程的起点。 下面代码演示了函数模板和类模板的使用方法： // 函数模板 template T add(const T& a, const T& b) { return a + b; } // 类模板 ...
c++模板元编程详解
05-31
所谓元编程就是编写直接生成或操纵程序的程序，C++ 模板给 C++ 语言提供了元编程的能力，模板使 C++ 编程变得异常灵活，能实现很多高级动态语言才有的特性（语法上可能比较丑陋，一些历史原因见下文）。普通用户对 ...
C++单例类模板详解
08-26
主要介绍了C++单例类模板，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
C++模板函数重载规则详解
12-26
模板函数重载匹配规则可以引用《c++ primer》中的一段话来总结： 对于一个调用，其候选函数包括所有模板实参推断成功的函数模板实例。 候选的函数模板总是可行的，因为模板实参推断会排除任何不可行的模板。 与...
C++模板之特化与偏特化详解
12-31
说到C++模板，这个已经不是什么新东西了，自己在实际开发中也用过；对于C++模板特化和偏特化，对于别人来说，已经不是什么新东西了，但是对于我来说，的确是我的盲区，那天在群里讨论这个问题，自己对于这部分确实...
（B站黑马C++）模板
IT OR 考公？
07-07 1439
记录代码，只用于复习
c++—模板（函数模板、类模板）
m0_72814368的博客
05-25 2183
c++—模板（函数模板、类模板）
c++模板
yaoyaohyl的博客
10-20 754
+。很多时候，由于程序员低估了模板实例化展开的开销，因此大量的模板使用会在代码中产生大量的余。这种余，有的时候已经使得编译器和链接器力不从心。++
c++ vector详解
05-14
它是一个模板类，可以存储任何类型的数据。 使用 vector 前需要包含头文件 vector。 ### 创建 vector 创建一个 vector 对象的语法如下： ```c++ vector<数据类型> 变量名; ``` 例如，创建一个存储整数的 vector...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值