17.1 c++ 模板

最新推荐文章于 2024-10-09 15:48:01 发布
最新推荐文章于 2024-10-09 15:48:01 发布
阅读量129 收藏
点赞数
分类专栏： C++基础 文章标签： c++ 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li7352223/article/details/129788662
版权
本文详细介绍了C++中的模板机制，包括函数模板和类模板的基本概念、定义方式、注意事项、重载以及局限性。函数模板允许实现泛型代码，减少重复编写相似功能的函数。类模板则实现了类的数据类型参数化，允许创建具有不同数据类型的类。同时，文章讨论了模板的类型推导、运算符重载在模板中的应用，以及模板作为友元和在继承中的使用情况。
摘要由CSDN通过智能技术生成

第十七章 模板

17.1 模板的概述

c++提供了函数模板（function templete)所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体订制，用一个虚拟的类型来代表。这个通用函数就成为函数模板。凡是函数体相同的函数都可以用这个模板代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现不同函数的功能。c++提供 两种模板机制：函数模板和类模板类属-类型参数化，又称参数模板。

总结：

​ c++面向对象编程思想：封装、继承、多态

​ c++泛型编程思想：模板

​ 模板的分类：函数模板、类模板

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

17.2 函数模板

17.2.1 函数模板的定义方式

模板关键字template

//T只能对当前函数有效
template<typename T>
void swapAll(T &a, T &b)
{
    T tmp = a;
    a = b;
    b = tmp;
    return;
}

int main()
{
    int a = 10, b = 20;
    //函数调用时 更具实参的类型 会自动推导T的类型
    swapAll(a,b);
    cout<<a<<" "<<b<<endl;
    
    char a1 = 'a',b1 = 'b';
    swapAll(a1,b1);
    cout<<a1<<" "<<b1<<endl;
}

函数模板 会编译两次：

​ 第一次：是对函数模板 本身编译

​ 第二次：函数调用处 将T的类型具体化

函数模板目标：模板是为了实现泛型，可以减轻编程的工作量，增强函数的重要性。

17.2.2 函数模板的注意点

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

//T只能对当前函数有效 typename可以换成class
template<typename T>
void swapAll(T &a,T &b)
{
	T tmp = a;
    a = b;
    b = tmp;
    cout<<"函数模板"<<endl;
    return;
}

void swapAll(int &a,int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
    cout<<"普通函数"<<endl;
    return;
}
int main()
{
    int a = 10, b = 20;
    swapAll(a,b);//调用普通函数
    cout<<a<<" "<<b<<endl;
}

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

int main()
{
	int a = 10, b=20;
	//强制使用函数模板
	swapAll<>(a,b);//调用函数模板
	swapAll<int>(a,b);
	cout<<a<<" "<<b<<endl;
}

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

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

void myPrintAll(int a,int b)
{
    cout<<a<<" "<<b<<endl;
    cout<<"普通函数"<<endl;
}
int main()
{
    myPrintAll(10,20);//普通函数
    myPrintAll('a','b');//函数模板
    myPrintAll(10,'b');//普通函数
    //强制说明T为int类型 就支持自动类型转换
    myPrintAll<int>(10,'b');//函数模板
}

17.2.3 函数模板的重载

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

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

17.2.4 函数模板的局限性

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

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

#include <iostream>
using namespace std;
class Data
{
	friend ostream& operator<<(ostream& out, Data ob);
private:
    int data;
public:
    Data(){}
    Data(int data)
    {
        this->data = data;
    }
};
ostream& operator<<(ostream& out, Data ob)
{
    out<<ob.data;
    return out;
}
template<typename T>
void myPrintAll(T a)
{
    cout<<a<<endl;
    cout<<"函数模板"<<endl;
}
int main()
{
    myPrintAll(10);
    myPrintAll('a');
    
    Data ob1(100);
    myPrintAll(ob1);
    
    return 0;
}

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

template<typename T>
void myPrintAll(T a)
{
    cout<<a<<endl;
    cout<<"函数模板"<<endl;
}
class Data
{
	friend void  myPrintAll<Data>(Data a);
private:
    int data;
public:
    Data(){}
    Data(int data)
    {
        this->data = data;
    }
};

//函数模板具体化
template<> void myPrintAll<Data>(Data a)
{
    cout<<a.data<<endl;
    cout<<"函数模板"<<endl;
}

int main()
{
    myPrintAll(10);
    myPrintAll('a');
    
    Data ob1(100);
    myPrintAll(ob1);
    
    return 0;
}

17.3 类模板

17.3.1 类模板基本概念

类模板和函数模板的定义和使用类似，我们已经进行了介绍。有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同。类模板用于实现类所需数据的类型参数化。

17.3.2 类模板的定义方式

//类模板
template<class T1,class T2>
class Data
{
private:
	T1 a;
	T2 b;
public:
	Data(){}
	Data(T1 a,T2 b)
	{
		this->a = a;
		this->b = b;
	}
	void showData()
	{
		cout<<a<<" "<<b<<endl;
	}
};

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

在这里插入图片描述

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

//类模板
template<class T1,class T2>
class Data
{
private:
	T1 a;
	T2 b;
public:
	Data(){}
	Data(T1 a,T2 b);
	void showData()
};
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()
{
    cout<<a<<" "<<b<<endl;
}

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

//类模板
template<class T1,class T2>
class Data
{
	template<typename T3,typename T4>
	friend void myPrintData(Data<T3,T4> &ob);
private:
	T1 a;
	T2 b;
public:
	Data(){}
	Data(T1 a,T2 b);
	void showData();
};

//函数模板
template<typename T3,typename T4> void myPrintData(Data<T3,T4> &ob)
{
	cout<<ob.a<<" "<<ob.b<<endl;
}
int main()
{
    Data<int,char> ob1(100,'A');
    myPrintData(ob1);
}

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

//类模板
template<class T1,class T2>
class Data
{
	friend void myPrintData(Data<T3,T4> &ob);
private:
	T1 a;
	T2 b;
public:
	Data(){}
	Data(T1 a,T2 b);
	void showData();
};
void myPrintData(Data<int,char> &ob)
{
    cout<<ob.a<<" "<<ob.b<<endl;
}
int main()
{
    Data<int,char> ob1(100,'A');
    myPrintData(ob1);
}

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

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);
};

#endif // DATA_H

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;
    cout<<"有参构造"<<endl;
}

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

main.cpp

#include <iostream>
#include "data.hpp"
using namespace std;

int main()
{
    Data<int,int> ob1(10,20);
    ob1.showData();
    return 0;
}

17.3.7 案例：设计数组类模板

myarray.hpp

#ifndef MYARRAY_HPP
#define MYARRAY_HPP
#include<iostream>
#include<string.h>
using namespace std;
template<class T>
class MyArray
{
    template<class T1>
    friend ostream& operator<<(ostream &out,MyArray<T1> ob);
private:
    T *arr;
    int size;
    int capacity;
public:
    MyArray();
    MyArray(int capacity);
    MyArray(const MyArray &ob);
    ~MyArray();
    MyArray& operator=(MyArray &ob);
    void pushBack(T elem);
    void sortArray();
};
#endif // MYARRAY_HPP

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

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

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

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

template<class T>
MyArray<T> &MyArray<T>::operator=(MyArray &ob)
{
    //判断this->arr是否存在旧空间
    if(arr != NULL)
    {
        delete [] arr;
        arr = NULL;
    }
    size = ob.size;
    capacity = ob.capacity;
    arr = new T[capacity];
    memset(arr,0,sizeof(T)*capacity);
    memcpy(arr,ob.arr,sizeof(T)*capacity);

    return *this;
}

template<class T>
void MyArray<T>::pushBack(T elem)
{
    //容器是否满
    if(size == capacity)
    {
        //扩展容量
        capacity = 2*capacity;

        //申请临时空间
        T *tmp = new T[capacity];

        if (arr != NULL)
        {
            //将旧空间拷贝到新空间中
            memcpy(tmp,arr,sizeof(T)*size);
            //释放旧空间
            delete [] arr;
        }

        //让arr指向新申请的空间
        arr = tmp;
    }
    arr[size] = elem;
    size++;
    return;
}

template<class T>
void MyArray<T>::sortArray()
{
    //如果size为0 不需要排序
    if(size==0)
    {
        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 tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }
    return;
}

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

main.cpp

#include <iostream>
#include<myarray.hpp>
#include<string>
using namespace std;

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>(Person ob)
    {
        return num>ob.num;
    }
};
ostream& operator<<(ostream &out, Person ob)
{
    cout<<ob.num<<" "<<ob.name<<" "<<ob.score<<endl;
}
int main()
{
    MyArray<int> arr1;
    arr1.pushBack(30);
    arr1.pushBack(20);
    arr1.pushBack(50);
    arr1.pushBack(10);
    arr1.pushBack(40);
    arr1.sortArray();
    cout<<arr1<<endl;

    MyArray<char> arr2;
    arr2.pushBack('C');
    arr2.pushBack('D');
    arr2.pushBack('B');
    arr2.pushBack('E');
    arr2.pushBack('A');
    arr2.sortArray();
    cout<<arr2<<endl;

    MyArray<Person> arr3;
    arr3.pushBack(Person(104,"lucy",88.8f));
    arr3.pushBack(Person(103,"bob",98.8f));
    arr3.pushBack(Person(102,"tom",78.8f));
    arr3.sortArray();
    cout<<arr3<<endl;
    return 0;
}

17.4 类模板的继承

17.4.1 类模板 派生出 普通类

#include <iostream>
using namespace std;
//类模板
template<class T1, class T2>
class Base
{
private:
    T1 a;
    T2 b;
public:
    Base(){}
    Base(T1 a,T2 b);
    void showData();
};
template<class T1,class T2>
Base<T1,T2>::Base(T1 a,T2 b)
{
    this->a = a;
    this->b = b;
}
template<class T1,class T2>
void Base<T1,T2>::showData()
{
    cout<<a<<" "<<b<<endl;
}

//类模板派生出普通类
class Son1:public Base<int,char>
{
public:
    int c;
public:
    Son1(int a, char b,int c):Ba se<int,char>(a,b){
        this->c = c;
    }
};
int main()
{
    Son1 ob1(100,'A',200);
    ob1.showData();
    cout<<ob1.c<<endl;
    return 0;
}

17.4.2 类模板 派生出 类模板

#include <iostream>

using namespace std;
//类模板
template<class T1,class T2>
class Base
{
private:
    T1 a;
    T2 b;
public:
    Base(){}
    Base(T1 a,T2 b);
    void showData();
};
template<class T1, class T2>
Base<T1,T2>::Base(T1 a, T2 b)
{
    this->a = a;
    this->b = b;
}

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

//类模板派生处类模板
template<class T1,class T2,class T3>
class Son1:public Base<T1,T2>
{
public:
    T3 c;
public:
    Son1(T1 a,T2 b,T3 c):Base<T1,T2>(a,b){
        this-> = c;
    }
};
int main()
{
    Son1<int,char,int>ob1(100,'A',200);
    ob1.showData();
    cout<<ob1.c<<enld;
    return 0;
}
alone_li
关注
专栏目录
c++ 模板教程（c语言中文网） 自己运行实例
digitalkee的博客
04-07 1473
注：本文的例子全部都是c语言中文网上的c++教程，自己只不过是运行了一遍而已。个别地方添加了点东西。 17.1模板函数入门 1.自己的第一个运行的程序（c语言中文网上源代码） // ConsoleApplication1.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <string> #include <iostream> using namespace std; template<typename T.
C++函数模板
2402_84626835的博客
07-24 179
在调用一个函数模板时，编译系统需要足够的信息来辨别每个虚拟类型参数所对应的实际类型，可以从不同的渠道获得这样的信息：从模板实参表中的<>或模板实参表中的()，模板实参的信息优先于函数实参的信息。如果从后者获得的信息已经能够判定其中部分或全部虚拟类型参数所对应的实际参数，而且它们又正好是参数表中最后的若干参数，则模板实参表中的几个参数可以省略。而用<类型修饰>声明的参数则称为常规参数，在形式上与普通的函数参数声明相同。其中的<模板参数表>由一个或多个<模板形参>组成，各<模板形参>之间用逗号隔开。
C++教程(最全)
热门推荐
HeiRen
03-04 37万+
C++简介
常用的C++面向对象编程模板
weixin_43684773的博客
09-10 405
目录1. 一些基础的规则2. 日期类2.1 日期类头文件2.2 日期类执行文件3. 书籍销售类3.1 书籍销售类头文件3.2 书籍销售类执行文件4. 指针类4.1 指针类1头文件4.2 指针类2头文件5. string类5.1 string类1头文件5.2 string类1执行文件5.3 string类2头文件5.4 string类2执行文件6. Account类6.1 Account类执行文件 —— 拥有静态成员7. StrVec类7.1 StrVec类头文件7.2 StrVec类执行文件8. Quote
C++17新特性
qq_44660367的博客
06-02 923
C++17是C++标准中的一个重要版本，它在语言核心和标准库中引入了许多新特性和改进，使得C++编程更加现代化和高效。、内联变量、新的标准属性以及文件系统库。是一个标准库类型，用于表示一个可能包含值也可能不包含值的对象，这在需要返回可能无效的结果时非常有用。结构化绑定允许将结构体、数组、元组等的成员解构到独立的变量中，简化了代码书写和提高了可读性。是一个类型安全的联合体，可以存储多个类型中的一种，并确保在访问时进行类型检查。是一个类型安全的容器，可以存储任意类型的值，类似于一个类型擦除的容器。
C++ Standard Library简介
03-10 1015
C++ Standard Library是C++语言标准库，由C++官方提供并定义了一系列标准的类型、函数和模板（包括输入/输出、字符串处理、数学计算、容器、算法等）。C++ Standard Library是C++语言的基础，并且是所有C++开发人员都应该掌握的知识点。 对于C++ Standard Library的开源项目框架，网上有很多资源可以参考，比如：
C++学习资料
zhangrelay的专栏
03-12 1352
很多学生朋友C++掌握的不够扎实，推荐一个免费品质不错的学习网站。 www.learncpp.com 简介/入门 0.1这些教程的介绍 0.2编程语言简介 0.3C/C++ 简介 0.4C++开发简介 0.5编译器、链接器和库简介 0.6安装集成开发环境 (IDE) 0.7编译你的第一个程序 0.8几个常见的 C++ 问题 0.9配置编译器：构建配置 0.10配置编译器：编译器扩展 0.11配置编译器：警告和错误级别 0.12配置编译器：选择语言标准 C++ 基础 1.1语句和程序结构 1.2注释 1
17.1迭代器
wudaijie的博客
07-16 247
采用这种看似复杂方式的原因是为了支持空区间(不包含任何元素的容器),此时。
C++ Primer 5e chapter 17.1
WhateverYoung的专栏
08-31 464
1、tuple，类似于pair，用于将一些数据组合成单一对象，又不想麻烦的定义一个类的时候，快速而随意的数据结构； 2、访问tuple成员，使用get函数模板； 3、常见用于是从一个函数返回多个值； 4、bitset，用于支持位运算，类模板，有固定大小，bitset x（“1100”）； 5、bitset存在很多检测或者设置一个或多个二进制位的方法，可以方便的检查哪些位置位，设置哪些位需要
C++ Primer中文版（第5版）李普曼 等著 pdf 1/3
02-24
　17.1 tuple类型 636 　17.1.1 定义和初始化tuple 637 　17.1.2 使用tuple返回多个值 638 　17.2 BITSET类型 640 　17.2.1 定义和初始化bitset 641 　17.2.2 bitset操作 643 　17.3 正则表达式 645 　17.3.1 使用...
C++数据抽象和问题求解（第6版）.[美]Frank M. Carrano(带详细书签).pdf
01-08
C++片段7 标准模板库 647 C7.1 STL容器 648 C7.1.1 STL容器适配器 649 C7.1.2 顺序容器 650 C7.1.3 关联容器 654 C7.2 STL算法 657 附录A 回顾C++基础 659 附录B 编程中的重要主题 697 附录C 统一建模语言 719 ...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1221
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【C语言系统编程】【第三部分：网络编程】3.2 数据传输和协议
10-03 1551
在进行网络编程时，有时需要设计并实现自定义协议，以满足特定应用的需求。自定义协议设计需要考虑到数据的传输、安全、效率等多方面因素。清晰性：协议应具有清晰的语法和语义，使开发者能快速理解和实现。扩展性：协议应允许未来的功能扩展，而不破坏现有功能。安全性：数据传输过程中应考虑加密和校验，以保证数据不被篡改。高效性：应尽可能减少网络带宽占用，提升数据传输效率。容错性：协议应能处理各种网络异常情况，如数据丢失、重复和延迟。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1729
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
42 C 语言 typedef：为基本数据类型、数组、指针、结构体、共用体起别名
最新发布
Thanks_ks的IT探秘之旅
10-09 304
本文全面介绍了 C 语言中 typedef 的使用方法和技巧。从为基本类型如 int、unsigned char 起别名，到为结构体、共用体、指针以及数组等复杂类型起别名，都进行了详细的阐述。通过具体示例，展示了如何分开定义结构体和别名、如何在结构体定义中直接使用 typedef、如何为匿名结构体起别名等高级用法。此外，还探讨了为指针和数组类型起别名的方法，并给出了综合案例，帮助读者更好地理解和应用 typedef。
【C++】STL——list的模拟实现
2301_77112794的博客
10-06 744
本文主要讲述了list的模拟实现
windows C++-创建数据流代理(三)
苏洛的博客
10-08 292
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
【C++力扣】917.仅仅反转字母|387.字符串中第一个唯一字符|415.字符串相加
白乐天_ξ( ✿＞◡❛)的博客
10-06 645
本文写的是力扣三道题的解答：917、387、415题，都是与string字符串有关的！
developerDiskImage17.1
11-08
developerDiskImage17.1是一种用于iOS开发的磁盘映像文件，它包含了iOS 17.1版本的开发工具和框架。开发人员可以使用这个映像文件来调试和测试他们的应用程序，以确保它们在最新版本的iOS上运行良好。此外，开发人员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值