c++学习笔记3_函数模板的使用并实现自己定义的队列

最新推荐文章于 2023-04-24 20:56:53 发布
最新推荐文章于 2023-04-24 20:56:53 发布
阅读量713 收藏
点赞数
分类专栏： C++从入门到放弃 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxm_jimin/article/details/126067362
版权

在这里插入图片描述
实验要求：
熟悉C

目录

1. 函数模板（Function Templates）

重载设计中，最理想的是对不同的参数类型做不同的事情。
比如swap函数，对于任何一个类型T的两个对象a、b，总能调用合适的swap(a,b)——函数模板实现

函数模板的定义：
在这里插入图片描述
关键字template告诉编译器，将要定义一个模板。
<>内的相当于函数的参数列表（模板形参 或 类型参数），每个模板形参都必须加上前缀typename或class
泛型标识符，例如Typename或T，称为类型参数（Type parameter），这意味这它们类似于变量，但是赋给它们的不能是数字，只能是类型。

例如：

template<class T>
int compare(const T&a,const T&b){
	if(a<b) return -1;
	else if(a>b) return 1;
	else return 0;
}

模板形参T（T为泛型名），数据形参a、b，函数返回类型int 。

函数模板不是函数，它是以具体的类型参数为实参来生成函数的模板。
函数模板定义被编译时，不会产生任何可执行代码。

类模板（Class Template）

如果让模板来工作，即省心又不降低效率，而且编译器依然可以对代码进行类型检查，还能保持代码的优雅和简洁。

类模板是一种模板，它通过在类定义上铺设类型参数的形式，表示具有相似操作的系列类（类族）。
template< class T> class Queue;中的Queue，即类模板名（class template name)，简称模板名（template name）

类模板不是类，而模板类是类。

template<class T> 
class Queue;
template<class T> 
class QueueItem{
//public:
private:
	T item;
	QueueItem *next;
	friend Queue<T>;
	QueueItem(const T &t):item(t),next(){}
//	friend ostream & operator<<(ostream &os,Queue<T> &q);
	friend ostream & operator<<(ostream &os,const Queue<T> &q);
};

template<class T> 
class Queue{
private:
	QueueItem<T> *head;
	QueueItem<T> *tail;
	//friend ostream & operator<<(ostream &os,const Queue<T> &q);
	friend ostream & operator<<(ostream &os,const Queue<T> &q){
		QueueItem<T> *p=q.head;
	//	Queue<T> *p=q.head;
		os<<"< ";
		while(p){
			os<<p->item<<" ";
			p=p->next;
		}
		os<<">"<<endl;
		return os;
	}
	void Destroy();
public:
	Queue():head(0),tail(0){}
	Queue(const Queue<T> &q){
		copyItems(q);
	}
	void push(const T &t);
	void pop();
	bool isEmpty(){
		return head==0;
	}
	T & front(){
		if(!isEmpty()){
			return head->item;
		}
	}
	~Queue(){
		Destroy();
	}
	void copyItems(const Queue<T> &q);

	template<class It>
	void copyItems(It beg,It end);
	template<class It>
	Queue(It beg,It end):head(0),tail(0){
		copyItems(beg,end);
	}
	template<class It>
	void assign(It beg,It end);
	Queue & operator=(const Queue&);
	Queue & operator()(const Queue&);
};

类模板实例化的过程，是根据具体的模板实参，替换成模板形参而产生除对应的模板类的过程。
例如：

Queue<int> l1;

模板特化

可以用模板实参来定做模板类。
类模板的模板实参通过实例化，构成模板的实例，它是定义好的模板类。
如果不想使用预定义的类模板来生成模板类，则是以该模板类名自己专门重写一个模板类，则得到模板特化（template specialization)，得到模板特化的过程，称为模板定做（template specializing)

模板定做时， template<> class 类模板名

以下为局部定做（partial specialization）
申明（放在.h文件中） ：

template<>
int compare<const char*>(const char * const &v1, const char * const &v2);

template<>
void Queue<const char*>::push(const char* const &t);

template<>
void Queue<const char*>::pop();

实现（只能放在.cpp文件中）：

template<>
void Queue<const char*>::push(const char* const &t){
	char *p=new char [strlen(t)+1];
	strncpy(p,t,strlen(t)+1);
	QueueItem<const char*>*qi=new QueueItem<const char*>(p);
	if(isEmpty()){
		head=tail=qi;
	}
	else{
		tail->next=qi;
		tail=qi;
	}
}

template<>
void Queue<const char*>::pop(){
	QueueItem<const char*>*qi=head;
	head=head->next;
	delete[] qi->item;
	delete qi;
}

template<>
int compare<const char*>(const  char* const &a,const  char* const &b){
	return strcmp(a,b);
}

实验部分

（熟悉C++的函数模板的使用并实现自己定义的队列)

sy3.h

#ifndef sy3
#define sy3
#include <iostream>
#include <string.h>
using namespace std;
template<class T> 
class Queue;

template<class T> 
class QueueItem{
//public:
private:
	T item;
	QueueItem *next;
//	friend Queue<T>;
	friend Queue<T>;
	QueueItem(const T &t):item(t),next(){}
//	friend ostream & operator<<(ostream &os,Queue<T> &q);
	friend ostream & operator<<(ostream &os,const Queue<T> &q);
};

template<class T> 
class Queue{
private:
	QueueItem<T> *head;
	QueueItem<T> *tail;
	//friend ostream & operator<<(ostream &os,const Queue<T> &q);
	friend ostream & operator<<(ostream &os,const Queue<T> &q){
		QueueItem<T> *p=q.head;
	//	Queue<T> *p=q.head;
		os<<"< ";
		while(p){
			os<<p->item<<" ";
			p=p->next;
		}
		os<<">"<<endl;
		return os;
	}
	void Destroy();
public:
	Queue():head(0),tail(0){}
	Queue(const Queue<T> &q){
		copyItems(q);
	}
	void push(const T &t);
	void pop();
	bool isEmpty(){
		return head==0;
	}
	T & front(){
		if(!isEmpty()){
			return head->item;
		}
	}
	~Queue(){
		Destroy();
	}
	void copyItems(const Queue<T> &q);

	template<class It>
	void copyItems(It beg,It end);
	template<class It>
	Queue(It beg,It end):head(0),tail(0){
		copyItems(beg,end);
	}
	template<class It>
	void assign(It beg,It end);
	Queue & operator=(const Queue&);
	Queue & operator()(const Queue&);
};



template<class T>
void Queue<T>::push(const T &t){
	QueueItem<T> *pItem = new QueueItem<T>(t);
	if(isEmpty()){
		head=tail=pItem;
	}
	else{
		tail->next=pItem;
		tail=pItem;
	}
}


template<class T>
void Queue<T>::pop(){
	if(isEmpty())
		return;
	QueueItem<T> *p=head;
	head=head->next;
	delete p;
}

template<>
void Queue<const char*>::push(const char* const &t);
template<>
void Queue<const char*>::pop();

template<class T>
void Queue<T>::Destroy(){
	while(!isEmpty()){
		pop();
	}
}
template<class T>
void Queue<T>::copyItems(const Queue<T> &q){
	QueueItem<T> *p=q.head;
	while(p){
		push(p->item);
		p=p->next;
	}
}
template<class T>
template<class It>
void Queue<T>::copyItems(It beg,It end){
	while(beg!=end){
		push(beg);
		beg++;
	}
}

template<class T>
Queue<T> &Queue<T>::operator=(const Queue & q){
	Destroy();
	copyItems(q);
} 
template<class T>
Queue<T> &Queue<T>::operator()(const Queue & q){
	Destroy();
	copyItems(q);
} 
template<class T>
template<class It>
void Queue<T>::assign(It beg,It end){
	Destroy();
	copyItems(beg,end);
}

template<class T>
int compare(const T&a,const T&b){
	if(a<b) return -1;
	else if(a>b) return 1;
	else return 0;
} 
template<>
int compare<const char*>(const  char* const &a,const  char* const &b);

#endif

sy3.cpp

#include "sy3.h"
#include<string>
#include<string.h>
using namespace std;

//类部分模板特化 
template<>
void Queue<const char*>::push(const char* const &t){
	char *p=new char [strlen(t)+1];
	strncpy(p,t,strlen(t)+1);
	QueueItem<const char*>*qi=new QueueItem<const char*>(p);
	if(isEmpty()){
		head=tail=qi;
	}
	else{
		tail->next=qi;
		tail=qi;
	}
}

template<>
void Queue<const char*>::pop(){
	QueueItem<const char*>*qi=head;
	head=head->next;
	delete[] qi->item;
	delete qi;
}

template<>
int compare<const char*>(const  char* const &a,const  char* const &b){
	return strcmp(a,b);
}

main.cpp

#include <iostream>
#include "sy3.h"
using namespace std;

//class Queue 的使用
int main() {
	Queue<int> l1;
	int a=1,b=2,c=3;
	l1.push(a);
	l1.push(b);
	l1.push(c);
	cout<<"l1"<<l1; 
	l1.pop();
	cout<<"l1"<<l1;
	
	Queue<double> l2;
	double d=1.1,e=2.2,f=3.3;
	l2.push(d);
	l2.push(e);
	l2.push(f);
	cout<<"l2"<<l2; 
	double front=l2.front();
	cout<<l2.front()<<endl;
	
	int x[5]={1,2,3,4,5};
	int y[5]={11,12,13,14,15};
	Queue<int> l3(1,4);
	cout<<"l3"<<l3; 
	Queue<double> l4;
	l4.copyItems(l2);
	cout<<"l4"<<l4; 
	
	Queue<int> l5;
	l5.copyItems(11,15);
	cout<<"l5"<<l5; 
	Queue<double> l6;
	l6(l4);
	cout<<"l6"<<l6; 
	Queue<int> l7;
	//l7=l4;
	l7.copyItems(1,3);
	cout<<"l7"<<l7; 	
	cout<<"compare(2,12)"<<compare(2,12)<<endl;
	cout<<"------------------------------------------"<<endl;
	cout<<"compare('ad','ab')"<<compare('ad','ab')<<endl;
	Queue<const char*>q1;
	q1.push("q1");
	q1.push("is");
	q1.push("there");
	cout<<"q1"<<q1;
	q1.pop();
	cout<<"q1"<<q1;
	
/**/	
	Queue<const char*>q2;
	//q2.copyItems(q1);
	q2(q1);
	cout<<"q2"<<q2;
	
	Queue<const char*>q3;
	q3=q1;
	cout<<"q3"<<q2;
	return 0;
}

运行结果：

在这里插入图片描述

zxm_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++Primer Plus书之--C++ 自定义队列的实现 和 成员初始化列表
c1392851600的专栏
12-16 770
队列模拟 队列的特点是先进先出, 栈是先进后出 要先定一个一个node, 里面存储的是数据和指向下一个节点的指针 struct Node { Item item; struct Node * next; } 这里的Item就是队列中需要存放的元素类型 Queue就是我们自己定义的队列对象: class Queue { private: enum {Q_SIZE = 10}; ...
c++实现队列
rouyu308的博客
08-25 2586
这里需要注意的是，由于上一个元素需要利用指针指向下一个元素，所以对象的建立需要用到new来分配堆上内存（同时要注意内存的释放）；队列使用类来实现，类中有数据和指针两项，数据为队列中每项的数据，指针为队列的当前元素指向下一个元素；
队列类(C++)
jakelihua
11-08 1309
构造函数：初始化队列：将初始尺寸保存到 size，将队首 front 和队尾 rear 均置为 0，为动态数组分配内存并将起始地址保存到 element。Dequeue 函数：若队列不空，则从队列中取出元素并保存到 value中，函数值为 true；size 为动态数组的尺寸，front 为队首元素的下标，rear 为队尾元素下一位置的下标，element 为动态数组的起始地址。Clear 函数：清空队列，将 front 和 rear 重置为 0，操作成功，函数值为 true。首先定义数据元素类型。
c++：模板
qq_51667621的博客
11-16 809
这里写自定义目录标题一、模板函数1.1一般模板函数1.2特化模板函数二、模板类2.1 模板类2.2 成员函数模板2.2 模板特化三、智能指针3.1 构造函数3.2 析构函数3.3 拷贝构造函数3.4 运算符重载四、总结 一、模板函数 1.1一般模板函数 模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。 模板是一种对类型进行参数化的工具； 通常有两种形式：函数模板和类模板； 函数模板针对仅参数类型不同的函数； 类模
C++ 线程 任务队列
langwang122的博客
01-18 4684
任务队列有点像windows的消息循环，有任务被压进队列就执行任务，否者就一直等待任务的到来。这样做的好处是外部程序不需要关心队列线程中的同步，只需要将任务压进队列即可，非常的方便。比如现在有一个下载任务要做，没有线程队列的情况下要自己创建线程，编写线程回调，在线程中下载并写文件落盘，必要的时候还要通知界面下载进度，下载完成后还要将线程销毁，有一系列的细节要处理。有了任务队列后只需要编写下载任务，...
C语言和C++Builder学习笔记.rar_C++笔记_c++学习笔记_c/C++_学习笔记_编程语言
09-20
本人在学习C/C++语言过程中所作的笔记
FFT_code.rar_C++实现FFT 迭代_C++实现fft函数_c++ fft函数_fft
09-23
FFT迭代算法的C++实现，内含比特翻转函数和FFT实现函数
C++基础语法学习笔记_C++初学者学习笔记_
09-30
刚入门学习C++，跟随b站黑马程序员学习，自己记录的一些小笔记。后面会根据学习继续慢慢更新！
C++利用链表模板类实现简易队列
08-26
主要为大家详细介绍了C++利用链表模板类实现一个简易队列，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
c++个人学习笔记归纳总结.rar_C++STL_X9H3_c++个人笔记总结
09-23
一、C++语言语法基础(6) 二、数据结构和算法 三、模板和STL 四、阶段项目
【跟学C++】C++队列——queue类(Study13)
cqy阳的博客
10-09 1119
【跟学C++】C++队列——queue类(Study13)
c++模板实现队列
weixin_34204057的博客
04-09 105
队列形象的说就是大家放学去餐厅买饭要排队一样，先去的人就能先吃到，first in first out说再多都是多余的，还是直接上代码吧（ps.简单粗暴的我，哈哈哈）.h#include<iostream>using namespace std;template<class T>struct Node{Node<T>* _next;T _...
C++利用模板实现一个队列
小小的天有大大的梦想
09-19 4661
开头总结：.利用模板类实现了一个队列，利用模板的好处是提供泛型编程，在存储数据的时候会适应不同类型的数据，减少了代码的书写，简化了程序的结构。#include using namespace std; //模板类 template class Queue { private: T arr[num]; int front; int rear;
c++ 用模板实现队列
cj1314528的博客
03-18 842
#include <iostream> using namespace std; //模板类 template <typename T, int num> class Queue { public: Queue(); ~Queue(); bool isEmpty(); bool isFull(); bool push(const T &); bool pop(T &); private: T arry[num]; int front; int .
C++模板实现队列
randyjiawenjie的专栏
08-28 5018
我准备练习一下模板的知识，然后自己实现vector类。在这之前，先用模板实现一个队列来热身吧。队列的底层是链表。主要是熟悉一下模板的写法。 另外，就是模板的定义和实现都要写在一个文件中（export关键字可以避免这样。还没用过），所以倒数第二行我加了个# include "qu
8.C++ Queue队列类模版实现
抵抗时间扭曲，坚持做一件有意义的事
02-25 1588
1.队列的介绍 队列的定义 队列（Queue）是一种线性存储结构。它有以下几个特点： 按照"先进先出（FIFO, First-In-First-Out）"方式进出队列。 队列只允许在"队首"进行取出操作(出队列)，在"队尾"进行插入操作(入队列) 队列实现的方式有两种 基于动态数组实现 基于链表形式实现 队列需要实现的函数 T dequeue() : 出队列,并返回取出的元素 void enqueue(const T &t) : 入队列 T &head() : 获取.
用c++模板类实现 顺序栈、循环队列所有的相关操作
2202_75383755的博客
04-24 229
【代码】用c++模板类实现 顺序栈、循环队列所有的相关操作。
P22-c++自己设计一个队列
梦悦foundation
02-16 538
文章目录1. 队列模扒1. 队列类2. Queue类的实现1. 嵌套结构和类3.类方法4.是否需要其他类方法？5. Customer类6. ATM模拟 1. 队列模扒 进一步了解类后,可将这方面的知识用于解决编程问题。 A 银行打算在 B 超市开设一个 自动柜员机(ATM)。 B超市的管理者担心排队等待使用ATM的人流会干扰超市的交通,希望限 制排队等待的人数。 A银行希望对顾客排队等待的时间进行估测。要编写一个程序来模拟这种情况,让超市的管理者可以了解ATM可能造成的影响。 对于这种问题,最自然的方法是使
c++队列及自定义结构体/类的指针队列问题
Talk is cheap. So look at my blog.
10-31 1456
c++队列存放的是元素的拷贝而不是元素本身，所以存在一个问题：当我们需要使用队列进行搜索，搜索的过程中又需要更改元素本身（如修改结构体内部某个指针等）应该怎么操作？ 尝试使用指针队列：发现对于基本类型int等可以实现（代码1），但自定义结构体、类无法实现。队列中存放的元素值都会变成最后一个入队的元素值。请问这是为啥？？(灬ꈍ ꈍ灬) 代码1：int的指针队列 #include<iostream> #include<queue> using namespace std; queue&
c++头文件定义模板类和模板函数，cpp文件实现函数功能
最新发布
06-03
在C++中，模板类和模板函数的定义和实现通常分离在不同的文件中。 首先，定义模板类或者模板函数的头文件中要包含模板参数列表和对应的成员或函数声明。例如，定义一个模板类`MyClass`： ```c++ // MyClass.h ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值