C++之模版

最新推荐文章于 2024-09-16 17:46:36 发布
最新推荐文章于 2024-09-16 17:46:36 发布
阅读量226 收藏 1
点赞数 10
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57907966/article/details/141205766
版权

模版

c++面向对象编程思想：封装、继承、多态
c++泛型编程思想：模板

将功能相同，类型不同的函数（类）的类型抽象成虚拟的类型。当调用函数（类实例化对象）的时候，编译器自动将虚拟的类型具体化。这个就是函数模板（类模板）

1、函数模版

#include <iostream>

using namespace std;


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

int main()
{
    int a=10;
    int b=20;
    swapAll(a,b);
    char aa='a';
    char bb='b';
    swapAll(aa,bb);
    return 0;
}

函数模板会编译两次：
第一次：是对函数模板 本身编译
第二次：函数调用处 将T的类型具体化
函数模板目标：模板是为了实现泛型，可以减轻编程的工作量，增强函数的重用性。

注意点：1、函数模板 和 普通函数 都识别。（优先选择 普通函数）

#include <iostream>

using namespace std;


void swapAll(int &a,int &b){
     cout<<"普通函数"<<endl;
    int temp=a;
    a=b;
    b=temp;
    return;
}

template<typename T>
void swapAll(T &a,T &b){
        cout<<"模版函数"<<endl;
    T temp=a;
    a=b;
    b=temp;
    return;
}

int main()
{
    int a=10;
    int b=20;
    swapAll(a,b);

    return 0;
}


普通函数

2、函数模板 和 普通函数 都识别。强制使用函数模板

    swapAll<>(a,b);//强制使用模版函数

3、函数模板自动类型推导时不能对函数的参数 进行自动类型转换。

#include <iostream>

using namespace std;

void printInt(int a,int b){
    cout<<"普通函数"<<endl;
    cout<<a<<' '<<b<<endl;
}



template<typename T>
void printInt(T a,T b){
        cout<<"模版函数"<<endl;
        cout<<a<<' '<<b<<endl;
}

int main()
{

    printInt(10,20);//普通函数
       printInt('a','b');//模版函数


//模版函数并不支持自动类型转换

    printInt(10,'a');//普通函数
    
//函数模板显示指明T的具体类型 这时函数模板的参数 可以自动类型转换。
    printInt<int>(10,'a');//模版函数


    return 0;
}

4、函数模板可以重载

template<typename T>
void printInt(T a){
    cout<<"模版函数"<<endl;
    cout<<a<<endl;
}

template<typename T>
void printInt(T a,T b){
        cout<<"模版函数"<<endl;
        cout<<a<<' '<<b<<endl;
}
int main()
{

    printInt(10,20);
    printInt(10);


    return 0;
}

5、模板的局限性

当函数模板推导出 T为数组或其他自定义类型数据 可能导致运算符不识别

解决办法一：运算符重载（推荐）

class Person{
    friend ostream &operator<<(ostream &out,Person p);
private:
    int age;
public:
    Person(int a){
        age=a;
    }

};
//重载输出运算符<<
ostream &operator<<(ostream &out,Person p){
    out<<p.age<<endl;
}

template<typename T>
void printInt(T a){
    cout<<"模版函数"<<endl;
    cout<<a<<endl;
}



int main()
{
    Person p(10);
    printInt(p);

    return 0;
}

解决办法二：具体化函数模板

template<typename T>
void printInt(T a){
    cout<<"模版函数"<<endl;
    cout<<a<<endl;
}


class Person{
//void printInt(T a)要在class Person前声明
  friend void printInt<Person>(Person a);//声明为友元函数不需要带上template<>
private:
    int age;
public:
    Person(int a){
        age=a;
    }

};


//函数模版具体化  --根据需要可以具体化
template <> void printInt<Person>(Person p){
    cout<<p.age<<endl;
}

int main()
{
    Person p(10);
    printInt(p);
    return 0;
}

2、类模版

类模版的定义

类模板 将类中类型 抽象成虚拟类型。

类模板 实例化对象 不能自动类型推导（重要）

template<class T1,class T2>
class Data{
private:
    T1 a;
    T2 b;
public:
    Data(){
        cout<<"无参构造"<<endl;
    }
    Data(T1 a,T2 b){
        this->a=a;
        this->b=b;

    }
    void showData(){
        cout<<a<<" "<<b<<endl;
    }
};

int main()
{
    //必须先指明类型，不能自动类型推导
    Data<int ,int> ob(10,20);
    ob.showData();

    return 0;
}

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

template<class T1,class T2>
class Data{
private:
    T1 a;
    T2 b;
public:
    Data(){
        cout<<"无参构造"<<endl;
    }
    Data(T1 a,T2 b){
        this->a=a;
        this->b=b;

    }
    void showData();
};
template<class T1, class T2>
void Data<T1, T2>::showData()
{
    cout<<a<<" "<<b<<endl;
}

函数模板作为类模板的友元

template<class T1,class T2>
class Data{
    template <class T3,class T4>//如果是T1和T2就与Data类的参数同名了,需要指明类模板参数
    friend void showData(Data<T3,T4> ob);//注意friend的位置
private:
    T1 a;
    T2 b;
public:
    Data(){
        cout<<"无参构造"<<endl;
    }
    Data(T1 a,T2 b){
        this->a=a;
        this->b=b;

    }

};
template <typename T3,typename T4>
void showData(Data<T3,T4> ob){
    cout<<ob.a<<" "<<ob.b<<endl;
}

int main()
{
    //必须先指明类型，不能自动类型推导
    Data<int,int> ob(10,20);
    showData(ob);

    return 0;
}

普通函数作为类模板的友元

template<class T1,class T2>
class Data{
    template <class T3,class T4>//如果是T1和T2就与Data类的参数同名了
    friend void showData(Data<T3,T4> ob);

    friend void myPrintData(Data<int,char> &ob);
private:
    T1 a;
    T2 b;
public:
    Data(){
        cout<<"无参构造"<<endl;
    }
    Data(T1 a,T2 b){
        this->a=a;
        this->b=b;

    }

};

//模版函数作为模版类的友元
template <typename T3,typename T4>
void showData(Data<T3,T4> ob){
    cout<<ob.a<<" "<<ob.b<<endl;
}

//普通函数作为模版类的友元
void myPrintData(Data<int,char> &ob){

    cout<<ob.a<<" "<<ob.b<<endl;

}
int main()
{
    //必须先指明类型，不能自动类型推导
    Data<int,int> ob(10,20);
    showData(ob);
    Data<int,char> ob2(10,'a');
    myPrintData(ob2);

    return 0;
}

类模板的继承:

1、类模板派生出普通类
template<class T1,class T2>
class Base{
private:
    T1 a;
    T2 b;
public:
    Base(){
        cout<<"无参构造"<<endl;
    }
    Base(T1 a,T2 b){
        this->a=a;
        this->b=b;
    }
    void showData(){
        cout<<a<<" "<<b<<endl;
    }

};
//类模板派生处普通类
class Son1:public Base<int,char>{
public:
    int  c;
public:
    Son1(int a ,char b,int c):Base<int,char>(a,b){//调用父类的构造方法
        this->c=c;

    }
};



int main()
{
    Son1 ob(10,'a',100);
    ob.showData();
    cout<<ob.c<<endl;
    return 0;
}
2、类模板派生出类模板
template<class T1,class T2>
class Base{
private:
    T1 a;
    T2 b;
public:
    Base(){
        cout<<"无参构造"<<endl;
    }
    Base(T1 a,T2 b){
        this->a=a;
        this->b=b;
    }
    void showData(){
        cout<<a<<" "<<b<<endl;
    }

};
//类模板派生处普通类
class Son1:public Base<int,char>{
public:
    int  c;
public:
    Son1(int a ,char b,int c):Base<int,char>(a,b){
        this->c=c;

    }
};


//类模版派生出类模版
template <class T1,class T2,class T3>
class Son2:public Base<T1,T2>{
public :
    T3 c;
public:
    Son2(T1 a,T2 b,T3 c):Base<T1,T2>(a,b){
        this->c=c;
    }
};


int main()
{
    Son2<int ,char ,int> ob(10,'a',100);
    ob.showData();
    cout<<ob.c<<endl;
    return 0;
}

类模板头文件和源文件分离问题

类模板最好存储在.hpp中（.h和.cpp的结合）

data.hpp

#ifndef DATA_H
 #define DATA_H
 #include<iostream>
 using namespace std;
 template<class T1, class T2>
 class Data
 {
 private:
 T1 a;
 T2 b;
 public:
 Data();
 Data(T1 a, T2 b);
 void showData(void);
 };
 
//类外实现
 template<class T1, class T2>
 Data<T1, T2>::Data()
 {
 cout<<"无参构造"<<endl;
 }
 template<class T1, class T2>
 Data<T1, T2>::Data(T1 a, T2 b)
 {
 this‐>a = a;
 this‐>b = b;
 }
 template<class T1, class T2>
 void Data<T1, T2>::showData(void)
 {
 cout<<a<<" "<<b<<endl;
 }
 #endif // DATA_H

main.cpp中

 #include <iostream>
 #include"data.hpp" #引入类模板.hpp
 using namespace std;

 int main(int argc, char *argv[])
 {
 Data<int,char> ob1(100,'A');
 ob1.showData();
 return 0;
 }

设计数组类模板

MyArray.hpp

#ifndef MYARRAY_H
#define MYARRAY_H
#include <iostream>
#include <string>
#include <string.h>
using  namespace std;


template<class T>
class MyArray{

    template<typename T1>
    friend ostream& operator<<(ostream &out,MyArray<T1> ob);

private:
    T *arr;
    int size;//大小
    int capcity;//容量
public:
    MyArray();
    MyArray(int  capacity);
    MyArray(const MyArray &ob);//拷贝函数
    ~MyArray();//析构函数

    MyArray &operator=(MyArray &ob);//重构=

    void pushBack(T elem);//从数组末尾插入元素
    void sortArray();//对数组进行排序

};
#endif // MYARRAY_H

//类外实现
template<class T>
MyArray<T>::MyArray(){
    capcity=0;
    size=0;
    arr=NULL;
}

template<class T>
MyArray<T>::MyArray(int capacity){
    this->capcity=capacity;
    size=0;
    arr=new T[this->capcity];
    memset(arr,0,sizeof(T)*capacity);
}

template<class T>
MyArray<T>::MyArray(const MyArray &ob){
    if(ob.arr==NULL){
        arr=NULL;
        size=0;
        capcity=0;
    }
    else{
        capcity=ob.capcity;
        size=ob.size;
        arr=new T[capcity];;
        memcpy(arr,ob.arr,sizeof(T)*capcity);
    }
}

template<class T>
MyArray<T>::~MyArray(){
    if(arr!=NULL) delete[]arr;
}




template<class T>
void MyArray<T>::pushBack(T elem){


    if(size==capcity){
        //满了
        capcity=(capcity==0?1:2*capcity);
        T *temp=new T[capcity];
        if(arr!=NULL){
            memcpy(temp,arr,sizeof(T)*capcity);
            delete[]arr;
        }
        arr=temp;
    }


    arr[size++]=elem;
    return;
}


template<class T>
MyArray<T> &MyArray<T>::operator=(MyArray<T> &ob){
    if(arr!=NULL){
        delete[] arr;
        arr=NULL;
    }
    size=ob.size;
    capcity=ob.capcity;
    arr=new T[capcity];

    memset(arr,0,sizeof(T)*capcity);
    memcpy(arr,ob.arr,sizeof(T)*capcity);
    return *this;
}


template<class T>
void MyArray<T>::sortArray(){

    if(arr==NULL){
        cout<<"容器为空"<<endl;
    }
    else{

        int i=0,j=0;
        for(i=0;i<size-1;i++){
            for(j=0;j<size-i-1;j++){
                if(arr[j]>arr[j+1]){
                    T temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
    return;
}

template<typename T1>
ostream& operator<<(ostream &out,MyArray<T1> ob){
    int i=0;
    for(i=0;i<ob.size;i++){
        out<<ob.arr[i]<<" ";
    }
    return out;
}

main.cpp

#include"MyArray.hpp"

class Person{
    friend ostream &operator<<(ostream &out,Person ob);
private:
    int num;
    string name;
    float score;
public:
    Person(){}
    Person(int num,string name,float score){
        this->num=num;
        this->name=name;
        this->score=score;
    }
    bool operator>(const Person &ob){
        return num>ob.num;
    }

};

ostream& operator<<(ostream &out,Person ob){
    int  i=0;
    out<<ob.num<<" "<<ob.name<<" "<<ob.score<<endl;
    return out;
}

int main()
{
     MyArray<int> ob1(5);
     ob1.pushBack(10);
     ob1.pushBack(30);
     ob1.pushBack(20);
     ob1.pushBack(50);
     ob1.pushBack(40);

     cout<<ob1<<endl;
     ob1.sortArray();
     cout<<ob1<<endl;

    MyArray<char> ob2(5);
     ob2.pushBack('A');
     ob2.pushBack('C');
     ob2.pushBack('D');
     ob2.pushBack('B');
     ob2.pushBack('F');

     cout<<ob2<<endl;
     ob2.sortArray();
     cout<<ob2<<endl;
     MyArray<Person> ob3(5);
     ob3.pushBack(Person(100,"lucy", 88.8f));
     ob3.pushBack(Person(103,"bob", 89.9f));
     ob3.pushBack(Person(105,"tom", 98.8f));
     ob3.pushBack(Person(102,"德玛", 99.8f));
     cout<<ob3<<endl;
     ob3.sortArray();
     cout<<ob3<<endl;




    return 0;
}
白小筠
关注
专栏目录
C++之模板＜template＞
gangaue的博客
05-28 1万+
目录🌈前言🌸 模板🌷1、泛型编程🌺2、函数模板🍀2.1、函数模板的概念🍁2.2、函数模板的格式🍂 2.3、函数模板的原理🍌2.4、函数模板的实例化🍃 2.5、模板参数的匹配原则🍒 3、类模板🍕 3.1、类模板的概念🍔 3.2、类模板的格式🍒3.3、类模板的实例化🍖 4、非类型模板参数🍗 5、模板的特化🍙5.1、特化的概念🍛5.2、函数模板的特化🍜5.3、类模板特化🍝 5.3.1、类模板全特化🍞 5.3.2、类模板的偏特化🍟6、模板的分离编译🎆6.1、 什么是分离编译🎆6. 2、解决方法🎇7、模板总结 🌈前
c++ 定义模板
m0_56077202的博客
04-12 1595
定义模板 当定义一个比较函数时，因为参数类型包括int、float、char等等，若为每个类型都定义一个比较函数，就不得不重复定义完全一样的函数体，并且需要确定要比较的所有类型，就比较麻烦了。 函数模板 ： 以关键字开始 加一个模板参数列表 template <typename T> 这样就可以定义一个通用的函数模板，而不是为每一数据类型都定义一个新函数 template <typename T> int compare(const T &v1,const T &v
C++之模板
flyingcloud6的博客
10-12 1443
来看看下面这段代码共有三个Max函数，内部执行的功能都是一样的求较大值，但就是参数类型不同，我们在求不同类型的时候，就要分别写出其对应的函数，这个时候就是很麻烦，代码了，那么我们就会思考，能不能写一个，不管什么类型的参数，都能去实现Max功能呢？(就像流水线生成的时候，机械化的进行一些步骤，我们只需要在进行一点小小的操作就能变成不同的产品)
C++之模板类&模板函数
TiRan_Yang
08-25 1741
模板类 模板类的定义使用template<typename T>或template<class T>，将具有相同功能的代码合并，增加代码的简洁性和易读性。例如在计算凸包的例子中，传入点的类型可以是自定义的Point，也可以是pcl::point之类。 例如在头文件中的定义如下： template<typename T> class POLYGON { public: POLYGON(); public: void convhull(std::vector&
C++之模板类派生子类
zy010101博客
04-04 1694
从模板类派生普通类 template<typename T> class Parent { public: Parent(T a); ~Parent(); private: T a; }; template<typename T> //模板的作用范围是紧随其后的一个类或者函数 Parent<T>::Parent(T a) //Parent&...
C++函数模板
weixin_44205961的博客
09-06 5463
模板是一个通用框架，是C++泛型编程思想的主要体现。C++提供了函数模板和类模板两种模板机制，本文介绍的是函数模板相关的知识。
C++类模板详解
weixin_44115575的博客
03-27 2939
类模板是一种用来生成类定义的模板，其中可以包含一个或多个类型参数。这些类型参数可以在定义类的时候替换为任意类型，从而使得我们能够创建适用于多种数据类型的通用类定义。类模板的定义使用 template或来声明一个类型参数。
C++之函数模板
程序员的规则
11-28 6953
函数模板
【C++】模板详解
2301_77954967的博客
07-27 2286
C++模板作为C++语言的强大特性，具有不可忽视的重要性和显著的优势。其重要性体现在，极大地提高了代码的复用性，减少了重复代码的编写；通过编译时的类型检查保障了代码的类型安全；为泛型编程、容器类、算法库等提供了坚实的基础，使代码更具通用性和可扩展性。本篇博文对C++模板做了一个较为详细的介绍，不知道对你有没有帮助呢觉得博主写得还不错的三连支持下吧！会继续努力的~
C++ 函数模板基础
英雄哪里出来
05-22 4037
C++ 函数模板基础
C++之模板编程
06-19
总而言之，C++模板编程是C++语言的一大特色，它为程序员提供了一种编写与数据类型无关的代码的能力。通过合理运用模板，不仅可以提高代码的复用性和可维护性，还可以通过泛型编程解决更多通用问题。然而，模板编程的...
C++之模板和可变模板参数
03-25
C++之模板和可变模板参数
c++文件模板 c++文件模板
02-24
c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件...
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1117
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
qq_74190237的博客
09-13 283
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 541
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C++_map_set详解
最新发布
2302_77644537的博客
09-16 850
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 584
继续学习头文件的数学函数。
C++ 中 vector 的常用功能介绍
2202_75569688的博客
09-12 432
在 C++ 中，vector是一种常用的动态数组容器，提供了方便的自动扩展、内存管理以及各种便捷的操作方法。它是 C++ 标准模板库（STL）的一部分，适用于需要动态存储和管理大量元素的场景。在本文中，我们将简要介绍vector的常用功能，展示如何对其进行操作和排序。为了简洁起见，假设我们已经使用了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值