C++之模板

已于 2023-02-11 14:23:44 修改
阅读量156 收藏
点赞数
文章标签： c++ 开发语言
于 2023-02-10 10:07:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43797135/article/details/128834296
版权

        模板能够使开发人员快速建立具有类型安全的类库集合和函数集合，大大方便了大规模软件开发。

函数模板：

        其本质上并不是一个实在的函数，编译器不能生成可执行代码。只是一个对函数功能框架的描述，根据传递的实际参数决定其功能。

函数模板的定义：

template <模板参数>
返回类型 函数名（形参列表）
{
    ...
}
//template是关键字，<模板参数>使用关键字class或typedef

 例如求和模板：

#include<iostream>
#include<string>
using namespace std;
//函数模板
template<class type>
type Sum(type x,type y)
{
	return x+y;
}
void main()
{
    //使用函数模板，传递参数不同，实现的功能不同
	int iresult = Sum(10,20);
	double dresult = Sum(1.0,2.0);
	cout<<iresult<<endl;
	cout<<dresult<<endl;
}

函数模板的作用：按照字面意思理解，他就是一个模板，只要是要实现的功能一样，就可以使用这个模板。比如我要求两个数谁大谁小，一个模板就可以被任何数据类型的比较拿来用。

//求最大值
template<class type>
type Max(type x,type y)
{
	return (x>y)?x:y;
}
void main()
{
	int iresult = Max<int>(10,20);
	double dresult = Max<double>(5.0,2.0);
	cout<<iresult<<endl;
	cout<<dresult<<endl;
}

//
//type相当于自定义的一个数据类型，类似于int,double
template<class type,int len>
type Max(type array[len])
{
	type ret = array[0];
	for(int i = 0;i<len;i++)
	{
		ret = (ret>array[i])?ret:array[i];
	}
	return ret;
}
void main()
{
	int array[5] = {5,6,2,3,7};
	int iret = Max<int,5>(array);//调用方式 函数名<输入模板参数>（函数本身的参数）
	
	double shuzu[3] = {14,2,30};
	double dret = Max<double,3>(shuzu);
	cout<<iret<<endl;
	cout<<dret<<endl;
}

类模板：

        类模板可以说是类生成类，减少了类的定义数量。是用来描述通用数据类型或处理方法的机制，它使类中的一些数据成员和成员函数的参数或返回值可以取任意数据类型。

类模板的定义：

template<类型形式参数表> class 类模板名
{
    ...
};

//类模板成员函数定义为：
template <类型形式参数表>
返回类型 类模板名<类型名表>::成员函数名(形参列表)
{
    ...
}

代码实例：

简单类模板

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

//简单类模板
template<class T1,class T2>//类模板有两个参数
class MyTemplate
{
	T1 t1;
	T2 t2;
	public:
		MyTemplate(T1 t_1,T2 t_2)//构造函数
		{
			t1 = t_1,t2 = t_2;
		}
		void display()
		{
			cout<<t1<<' '<<t2<<endl;
		}
};
void main()
{
	int a = 123;
	double b = 3.1415;
	MyTemplate<int,double> mt(a,b);//指明传入参数的类型
	mt.display();
}

默认参数模板：在定义时设置类型参数表中一个类型参数默认值，有了默认的数据类型参数后，在定义新类时就可以不进行指定。

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

//简单类模板
template<class T1,class T2=int>//定义默认参数
class MyTemplate
{
	T1 t1;
	T2 t2;
	public:
		MyTemplate(T1 t_1,T2 t_2)//构造函数
		{
			t1 = t_1,t2 = t_2;
		}
		void display()
		{
			cout<<t1<<' '<<t2<<endl;
		}
};
void main()
{
	int a = 123;
	double b = 3.1415;
	MyTemplate<int,double> mt1(a,b);//指明传入参数的类型
	MyTemplate<int>mt2(a,b);//默认参数类型
	mt1.display();
	mt2.display();
}

123 3.1415
123 3

为具体类型的参数提供默认值：直接上实例

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

//为具体类型的参数提供默认值
template<class T1,class T2,int num=10>//定义默认值
class MyTemplate
{
	T1 t1;
	T2 t2;
	public:
		MyTemplate(T1 t_1,T2 t_2)//构造函数
		{
			t1 = t_1+num;
			t2 = t_2+num;
		}
		void display()
		{
			cout<<t1<<' '<<t2<<endl;
		}
};
void main()
{
	int a = 123;
	double b = 3.1415;
	MyTemplate<int,double> mt1(a,b);//默认加10
	MyTemplate<int,double,100>mt2(a,b);//修改参数，可以加任意值
	mt1.display();
	mt2.display();
}
133 13.1415
223 103.141

有界数组模板 ：C++语言不能检测数组下标是否越界，通过建立数组模板，对数组下标是否越界进行检测，在模板中想要获取下标值，需要重载数组下标运算符"[]"，重载数组下标运算符后使用模板类实例化的数组，就可以进行下标越界检测。

        因为程序需要使用assert来进行警告处理，且需要对话框显示，需要引入头文件cassert。

#include<iostream>
#include<iomanip>//用来对输入输出操作的格式进行更加方便的控制用来对输入输出操作的格式进行更加方便的控制
#include<cassert>
using namespace std;

//定义一个普通类Date
class Date
{
    int Month,Day,Year;
    char Format[128];

public:
    Date(int m=0,int d=0, int y=0)//构造函数，用于对变量进行初始化
    {
        Month = m;
        Day = d;
        Year = y;
    }

    //ostream是output stream的简称，即输出流.ostream这个类型，往往出现在(操作重载中，作为某个类的友元函数出现)
    friend ostream& operator<<(ostream& os, const Date t)
    {
        cout<<"Month:"<<t.Month<<' ';
        cout<<"Day:"<<t.Day<<' ';
        cout<<"Year:"<<t.Year<<' ';

        return os;
    }

    void Display()
    {
        cout<<"Month:"<<Month;
        cout<<"Day:"<<Day;
        cout<<"Year:"<<Year;
        cout<<endl;
    }
};
//有界数组模板，用于检测是否越界(写法是固定的)
template<class T,int b>
class Array
{
    T elem[b];
public:
    Array(){}
    T& operator [](int sub)
    {
        assert(sub>=0&&sub<b);
        return elem[sub];
    }
};
//主函数用于测试
int main()
{
    Array<Date,3> dataArray;//有界数组检测模板,即数组长度为3
    //定义三个日期
    Date dt1(1,2,3);
    Date dt2(4,5,6);
    Date dt3(7,8,9);
    //将三组数据添加到检测模板中
    dataArray[0] = dt1;
    dataArray[1] = dt2;
    dataArray[2] = dt3;
    //依次输出检测信息
    for(int i = 0;i<3;i++)
        cout<<dataArray[i]<<endl;

    //第四组数据异常，超过数组长度
    Date dt4(10,11,13);
    dataArray[3] = dt4;
    cout<<dataArray[3]<<endl;
    return 0;

}


//程序输出
Month:1 Day:2 Year:3
Month:4 Day:5 Year:6
Month:7 Day:8 Year:9
Assertion failed!

Program: D:\\1\test\bin\Debug\test.exe
File: D:\桌面\1\test\main.cpp, Line 47

Expression: sub>=0&&sub<b

模板的使用

1、定制模板

        定义完模板之后若想对模板功能进行扩充，需要对类模板进行覆盖，这种覆盖操作称之为定制。

例如：定制一个类模板，然后覆盖模板中所定义的所有成员。

#include<iostream>
#include<iomanip>//用来对输入输出操作的格式进行更加方便的控制用来对输入输出操作的格式进行更加方便的控制
using namespace std;

//定义一个普通类Date
class Date
{
    int Month,Day,Year;
    char Format[128];

public:
    Date(int m=0,int d=0, int y=0)//构造函数，用于对变量进行初始化
    {
        Month = m;
        Day = d;
        Year = y;
    }

    //ostream是output stream的简称，即输出流.ostream这个类型，往往出现在(操作重载中，作为某个类的友元函数出现)
    friend ostream& operator<<(ostream& os, const Date t)
    {
        cout<<"Month:"<<t.Month<<' ';
        cout<<"Day:"<<t.Day<<' ';
        cout<<"Year:"<<t.Year<<' ';

        return os;
    }

    void Display()
    {
        cout<<"Month:"<<Month;
        cout<<"Day:"<<Day;
        cout<<"Year:"<<Year;
        cout<<endl;
    }
};
//定义Set类模板
template<class T>
class Set
{
    T t;
public:
    Set(T st):t(st){}
    void Display()
    {
        cout<<t<<endl;
    }
};
template<>
class Set<Date>//使用Date对整个类模板进行了定制
{
    Date t;
public:
    //两个成员函数都需要进行重写
    Set(Date st):t(st){}
    void Display()
    {
        cout<<"Date:"<<t<<endl;
    }
};
//主函数用于测试
int main()
{
    Set<int> intset(123);
    Set<Date> dt=Date(1,2,3);
    intset.Display();//原模板的输出 123
    dt.Display();//定制后的输出  Date:Month:1 Day:2 Year:3
    return 0;

}

若要覆盖模板中指定的成员：

template <class T>
//指定特定成员函数
void Set<Date>::Dispaly()
{
    //进行重写
    cout<<"Date:"<<t<<endl;
}

链表类模板 

下例是一个基础的链表定义及操作：

#include<stdio.h>
#include<iostream>
using namespace std;

//节点类
class Node
{
public:
    int data;
    Node *next;
    Node()
    {
        next = NULL;
    }
};
//链表类
class List
{
private:
    Node *Header;
    int NodeSum;
public:
    //链表初始化
    List()
    {
        Header = NULL;
        NodeSum = 0;
    }
    //移动尾节点
    Node* MoveTrail()
    {
        Node *ptail = Header;
        for (int i = 1;i<NodeSum;i++)
        {
            ptail = ptail->next;
        }
        
        return ptail;
    }
    //添加节点
    void AddNode(Node *pNode)
    {
        if (NodeSum == 0)
            Header = pNode;
        else
        {
            Node *p = MoveTrail();
            p->next = pNode;
        }
        NodeSum++;
    }
    //遍历链表
    void PassList()
    {
        if (NodeSum > 0)
        {
            Node *ptemp = Header;
            printf("%d",ptemp->data);
            for(int i = 1;i<NodeSum;i++)
            {
                ptemp = ptemp->next;
                printf("%d",ptemp->data);
            }
        }
    }
    
    //析构函数
    ~List()
    {
        if(NodeSum>0)
        {
            Node *Delate = Header;
            Node *p = NULL;
            for(int i = 0;i<NodeSum;i++)
            {
                p = Delate->next;
                delete Delate;
                Delate = p;
            }
            NodeSum = 0;
            //指针置空，以防变成野指针
            Delate = NULL;
            p = NULL;
        }
        Header = NULL;
    }
};

链表的最大缺陷就是不够灵活，其节点形式只能是Node类型。若让List能适应各种类型的节点的最简单的办法就是使用类模板。

则重新定义链表类使其成为链表类模板：

#include<stdio.h>
#include<iostream>
using namespace std;

class Node
{
public:
    int data;
    Node *next;
    Node()
    {
        next = NULL;
    }
};

template<class Type> //修改一：将原链表的Node类型全部替换为模板参数Type
class List
{
private:
    Type *Header;
    int NodeSum;
public:
    //链表初始化
    List()
    {
        Header = NULL;
        NodeSum = 0;
    }
    //移动尾节点
    Type* MoveTrail()
    {
        Type *ptail = Header;
        for (int i = 1;i<NodeSum;i++)
        {
            ptail = ptail->next;
        }

        return ptail;
    }
    //添加节点
    void AddNode(Type *pNode)
    {
        if (NodeSum == 0)
            Header = pNode;
        else
        {
            Type *p = MoveTrail();
            p->next = pNode;
        }
        NodeSum++;
    }
    //遍历链表
    void PassList()
    {
        if (NodeSum > 0)
        {
            Type *ptemp = Header;
            printf("%d ",ptemp->data);
            for(int i = 1;i<NodeSum;i++)
            {
                ptemp = ptemp->next;
                printf("%d ",ptemp->data);
            }
        }
    }

    //析构函数
    ~List()
    {
        if(NodeSum>0)
        {
            Type *Delate = Header;
            Type *p = NULL;
            for(int i = 0;i<NodeSum;i++)
            {
                p = Delate->next;
                delete Delate;
                Delate = p;
            }
            NodeSum = 0;
            //指针置空，以防变成野指针
            Delate = NULL;
            p = NULL;
        }
        Header = NULL;
    }
};


int main(int argc,char* argv [])
{
    List<Node> nodelist;//修改二，节点类型以参数的形式传入到模板中
    //循环添加节点
    for(int i = 0;i<5;i++)
    {
        Node *p = new Node;
        p->data = i;
        nodelist.AddNode(p);
    }
    //遍历链表
    nodelist.PassList();
    return 0;
}

 

Jane_Librastar
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言模板类,C++类模板（Class Template）
weixin_31954813的博客
05-20 1515
C++ 除了支持函数模板，还支持类模板(Class Template)。函数模板中定义的类型参数可以用在函数声明和函数定义中，类模板中定义的类型参数可以用在类声明和类实现中。类模板的目的同样是将数据的类型参数化。声明类模板的语法为：template class 类名{//TODO:};类模板和函数模板都是以 template 开头(当然也可以使用 class，目前来讲它们没有任何区别)，后跟类型参...
C++之模板编程
06-19
C++之模板编程，分析清晰合理，源自不错的学者，转载原文有注释
C++的template模板中class与typename关键字的区别分析
01-01
在C++模板中，可以使用class或者typename来声明模板参数，那么这两个关键字有什么区别呢？ 模板参数声明 对于模板参数声明，这两个参数没有区别，含义是一样的。 template class Simple; template class Simple; 上面两行都是声明一个模板类Simple. 表明类型 假如我们有这样一段代码: template void add(const T &acontainer, T &sum) { T::const_iterator iter = container.begin(); for (; iter != container.end()
C++类模板
好好学习，天天向上
05-04 1021
C++类模板和相关知识
C++ 语言类模板 (Class Template)
既然选择了远方 便只顾风雨兼程 - 永强
08-08 942
C++ 语言类模板 (Class Template) 根据“在定义变量时是否需要显式地指明数据类型”可以将编程语言分为强类型语言和弱类型语言。 1. 强类型语言 强类型语言在定义变量时需要显式地指明数据类型，并且一旦为变量指明了某种数据类型，该变量以后就不能赋予其他类型的数据了，除非经过强制类型转换或隐式类型转换。典型的强类型语言有 C/C++、Java 等。 int a = 100; a = (int)"http://c.biancheng.net"; // 强制转换 (得到字符串的地址) 2. 弱类型
c++类模板详解
m0_49133355的博客
07-18 380
通过理解类模板的定义、成员函数、多个模板参数、默认模板参数、继承、实例化和部分特化，开发者可以编写更加通用和灵活的代码，提升软件的可维护性和可扩展性。C++类模板是C++泛型编程的重要特性之一，允许类定义中的数据类型在实例化时指定，从而实现代码的重用和灵活性。类模板可以用来创建通用的类，而不必针对每种可能的数据类型编写单独的类。在类定义中，所有出现 T 的地方将由实例化时传递的具体类型替换。类模板可以有成员函数，与普通类的成员函数一样。类模板在使用时需要实例化，实例化时必须指定模板参数，除非参数有默认值。
C++之模板和可变模板参数
03-25
C++之模板和可变模板参数
C++基础之模板.pdf
03-11
C++模板是C++语言中的一个强大特性，它允许程序员创建泛化的函数和类，能够应用于多种数据类型，从而减少代码的重复，并提高程序的灵活性和类型安全性。模板的使用始于1994年，由Erwin Unruh在演示一个质数程序时...
c++文件模板 c++文件模板
02-24
c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件...
C++模板元编程
01-06
### C++模板元编程 #### 一、C++模板元编程概述 在现代软件开发领域，C++模板元编程（Template Metaprogramming）是一种利用C++编译器的类型系统来实现计算逻辑的技术。它允许程序员在编译时执行复杂的算法和数据...
C++面向对象程序设计 - 类模板
觉醒法师的专栏
04-11 1433
C++允许使用函数模板，对于功能相同而数据类型不同的一些函数，不必一一定义各个函数，可以定义一个可以对任何类型变量进行操作的函数模板，在调用函数时，系统会根据实参的类型，取代函数模板中的类型参数，得到具体函数。有时两个或多个类，其功能是相同的，仅仅是数据类型不同。显然这种重复性工作是不必要的，C++在发展后期增加了模板（template）的功能，提供了解决这类的途径；可以声明一个通用的类模板，它可以有一个或多个虚拟的类型参数，创建可以重用的组件，这些组件可以处理多种数据类型，而不仅仅是单一的数据类型。
C++模板编程（1）---类别模板Class Template
追赶时代的博客
06-14 794
C++ 模板编程 类别模板
C++模板
天道酬勤
06-03 2696
模板是C++中泛型编程的基础，一个模板就是一个创建类或函数的公式，当使用模板类型时，编译器会生成特定的类或函数，这个过程发生在编译时。 模板定义 模板定义以关键字template开始，后跟以个模板参数列表，这是一个逗号分隔的一个或多个模板参数的列表，用尖括号括起来。 template<typename T,typename M> 模板参数表示在类或函数定义中用到的类型或值，在使用模板...
c++模板之类模板
m0_73603082的博客
02-07 95
1.当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型，如果不能指定，编译器无法给子类分配内存。很容易理解：普通类的成员函数返回类型和参数类型都是确定的，而类模板的成员函数需要确认T的类型。类模板的作用：建立一个通用类，类中的成员，数据类型可以不具体制定，用一个虚拟的类型来代表。类模板和函数模板语法相似，在声明模板template后面加类，此类成为类模板。2.类模板在模板参数列表中可以有默认参数，并且默认实参要从形参列表的。类模板的成员函数类外现实时，需要加上模板参数列表。
C++ 模板详解——template＜class T＞
2402_83315537的博客
04-20 2793
通过使用函数模板，可以写出更通用、更灵活的代码，同时减少重复和错误。编译时的类型检查提供了比C语言中的宏更高的类型安全性。函数模板在C++标准库中被广泛使用，例如在STL（标准模板库）的各种算法和容器中。这使得STL非常强大，因为它不仅能够处理几乎任何类型的数据，还保持了代码的紧凑和高效。
C++学习笔记-函数模版与类模版
最新发布
chen_mp的博客
07-25 854
C++模板是C++语言中的一个重要特性，它使得代码能够重用和泛化，提高了编程的效率和代码质量。无论是函数模板还是类模板，都是编写高效、通用代码的重要工具。通过理解和掌握模板的使用，可以大大提高C++编程的灵活性和效率。
C++中的类模板详细讲述
assemble8086的专栏
10-03 1869
一、类模板定义及实例化 １. 定义一个类模板： template class 类名 { // 类定义．．．．．． } 其中，template 是声明类模板的关键字，表示声明一个模板，模板参数可以是一个，也可以是多个，可以是类型参数 ，也可以是非
c++中的 template<class Type>
点滴的岁月
05-22 8204
c++集合了过程式语言，通用语言，面向对象语言的众多特点。模板是通用语言的特性，模板又叫参数化类型（parametrized types）。 模板的定义。以下是模板定义的一般格式： 　　template //class 也可以换成typename，后者是新来的。 　　void swap(any &a,any &b) 　　{ ...... 　　} 利用模板机制可以显著减少
类模板template ＜class T＞
weixin_43294620的博客
02-07 5906
类模板template ＜class T＞ 类模板： 类模板是对一批仅仅成员数据类型不同的类的抽象，使用类模板可以极大地提高编程的效率。例如对于以下这个类： typedef unsigned long Item; class Stack { private: enum {MAX=10};//作用域内枚举，这里使用枚举的MAX只是一个符号名称，在作用域为整个类的代码中遇到时，将用10来代替 //注意在此处使用const int MAX = 10;是不行的，因为声明类只是描述了对象的形式，并没有创建对
C++标准模板库STL详解
"C++ PPT第9章 标准模板库STL.ppt" C++标准模板库（STL）是C++编程中一个至关重要的组成部分，它提供了一组高效且可重用的模板类和函数，使得程序员可以便捷地处理数据结构和算法。STL的出现极大地提升了C++的编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值