C++模板应用 -----queue

本篇我们将实现Queue的简单操作;

一、Queue版本1;

通过本程序,我们可以看到 pop、push 、back、front、size的简单操作的实现;

//Queue.hpp
#ifndef QUEUE_H_
#define QUEUE_H_

#include <deque>

template <typename T, typename V =std::deque<T>//默认的类型形参 >
class Queue
{
    public:
        typedef typename V::size_type size_type;

        Queue(){ }
        void push(const T &t)
        { elems_.push_back(t);  }//调用deque的函数
        void pop()
        { elems_.pop_front(); }

        const T &back()const
        { return elems_.back();}
        T &back()

        { return elems_.back();}
        const T &front()const
        { return elems_.front();}
        T &front()
        { return elems_.front();}

        size_type size()const
        { return elems_.size(); }

        bool empty()const
        { return elems_.empty(); }
    private:
        V elems_; ///唯一的数据成员
        //我们将类型为T的元素存储于 elemss_(deque)中,调用deque的接口,实现以上各个功能
};

#endif 

main.cpp

 1 #include "Queue.hpp"
 2 #include <iostream>
 3 #include <string>
 4 using namespace std;
 5
 6 int main(int argc, const char *argv[])
 7 {
 8     Queue<string> qu;
 9     qu.push("hello");
10     qu.push("world");
11
12     cout <<qu.size() << endl;
13
14     cout << qu.back()<< endl;
15
16     while( !qu.empty())
17     {
18         cout << qu.front()<< endl;
19         qu.pop();
20     }
21
22     return 0;
23 }

二、Queue版本2:

上面的程序尽管完成了一些操作,但是若要遇到一些问题,便束手无策了,例如:

现有类型 Queue<int,deque<int> > q1;

1、将 Queue<double, deque<double>> q2 类型的队列 复制或者赋值给 q1;(仅仅 将 int 换为double , deque没有发生变化)

2、又或者 将Queue<double, list<double> >  q3复制或者赋值给 q1;(将 int 换位 double, 将deque默认类型形参 换为  list)

以下程序帮我们实现此类转换:

Stack.hpp

 1 #ifndef QUEUE_H_
 2 #define QUEUE_H_
 3
 4 #include <deque>
 5
 6 template <typename T, typename V =std::deque<T> >
 7 class Queue
 8 {
 9     public:
10         typedef typename V::size_type size_type;
11         Queue(){}
12         //完成两种不同类型的转换,需要重置两个形参
13         //如Queue<int>-->Queue<double> || -->Queue<double, list<double> >
14         template <typename T2, typename V2>
15         Queue<T, V>(const Queue<T2, V2> &other);
16         template <typename T2, typename V2>
17         Queue<T, V> &operator=(const Queue<T2, V2> &other);
18
19         void push(const T &t)
20         { elems_.push_back(t);  }
21         void pop()
22         { elems_.pop_front(); }
23
24         const T &back()const
25         { return elems_.back();}
26         T &back()
27         { return elems_.back();}
28         const T &front()const
29         { return elems_.front();}
30         T &front()
31         { return elems_.front();}
32
33         size_type size()const
34         { return elems_.size(); }
35
36         bool empty()const
37         { return elems_.empty(); }
38     private:
39         V elems_;
40 };
41
42 template <typename T, typename V>  //注意要用两个模板声明
43 template <typename T2, typename V2>
44 Queue<T, V>::Queue(const Queue<T2, V2> &other) //copy构造函数
45 {
46     Queue<T2, V2> tmp(other); //将 other 拷贝
47     while( !tmp.empty())
48     {
49         push(tmp.front()); //赋值给当前queue<T,V>
50         tmp.pop();
51     }
52 }
53
54 template <typename T, typename V>
55 template <typename T2, typename V2>
56 Queue<T, V> &Queue<T,V>::operator=(const Queue<T2, V2> &other)
57 {
58     //判断两者是否相等
59     if((void*)this == (void*)&other)
60         return *this;
61     //删除元素
62     while( !empty() )
63         pop();
64     //复制元素
65     Queue<T2, V2> tmp(other);
66     while( !tmp.empty())
67     {
68         push(tmp.front());
69         tmp.pop();
70     }
71 }
72
73 #endif 

main.cpp

 1 #include "Queue.hpp"
 2 #include <iostream>
 3 #include <list>
 4 using namespace std;
 5
 6 int main(int argc, const char *argv[])
 7 {
 8     Queue<int> qt;
 9     qt.push(62);
10     qt.push(23);
11     qt.push(9);
12     qt.push(56);
13     qt.push(31);
14
15     cout << qt.size() << endl;
16
17     Queue<double> qt2(qt);
18     cout << "qt2" << endl;
19     while(!qt2.empty())
20     {
21         cout <<qt2.front() << endl;
22         qt2.pop();
23     }
24
25     Queue<double, list<double> > qt3;
26     qt3 = qt;
27     cout << "qt3" << endl;
28     while(!qt3.empty())
29     {
30         cout <<qt3.front() << endl;
31         qt3.pop();
32     }
33
34     return 0;
时间: 2024-12-21 21:52:47

C++模板应用 -----queue的相关文章

C++的标准模板库queue

template <class T, class Container = deque<T> > class queue; queues是一种容器适配器,用C++中的模板写成,设计的目的在于用来操作先进先出(FIFO)的线性表.它包含了队列的基本操作: empty    判断队列是否为空. size  返回队列的大小. front       获取队列队头的元素,不删除元素. back         获取队列队尾元素,不删除元素. push_back 入队,元素增加一个. pop_

C++STL模板之queue队列的用法

1 #include <iostream> 2 3 #include <queue> 4 5 #include <assert.h> 6 /* 7 调用的时候要有头文件: #include<stdlib.h> 或 #include<cstdlib> + 8 #include<queue> #include<queue> 9 详细用法: 10 定义一个queue的变量 queue<Type> M 11 查看是否为

模板类Queue的实现

1 #include <iostream> 2 #include <vector> 3 using namespace std; 4 5 template <class Type> class Queue; 6 template <class T > ostream & operator << (ostream &os, const Queue<T> &); 7 8 template <class Typ

借助queue的层次遍历---c++

今天的收获: 1.c++中存在queue模板 queue<template type> vec; vec.push(); vec.pop(); queue 没有清空操作,clear()等函数,因此可以定义一个新的空队列 queue< ** > newqu,然后 swap(vec,newqu ),这样就清空vec 了. 2.借助queue的层次遍历 思想:在遍历该节点时,将它的孩子几点入队. /** * Definition for a binary tree node. * str

C++ Primer 学习笔记_75_模板与泛型编程 --模板定义

模板与泛型编程 --模板定义 引言: 所谓泛型程序就是以独立于不论什么特定类型的方式编写代码.使用泛型程序时,我们须要提供详细程序实例所操作的类型或值. 模板是泛型编程的基础.使用模板时能够无须了解模板的定义. 泛型编程与面向对象编程一样,都依赖于某种形式的多态性.面向对象编程中的多态性在执行时应用于存在继承关系的类.我们能够编写使用这些类的代码,忽略基类与派生类之间类型上的差异.仅仅要使用基类的引用或指针,基类类型或派生类类型的对象就能够使用同样的代码. 在泛型编程中,我们所编写的类和函数能够

SPFA模板 Bellmanford优化版

SPFA模板: queue<int>Q; bool inq[510]; int dis[510],sumv[510]; int n,v[510*3],__next[510*3],e,w[510*3],first[510],cnts[510]; void AddEdge(int U,int V,int W) { v[++e]=V; w[e]=W; __next[e]=first[U]; first[U]=e; } bool spfa(const int &s) { memset(dis,

C++STL——队列

一.相关定义 原理:queue 队列也是一个线性存储表,元素数据的插入在表的一端进行,在另一端删除,从而构成了一个先进先出FIFO(First In First Out)表. 队头&队尾:插入一端称为队尾,删除一端称为队首. C++队列是一种容器适配器,默认使用双端队列deque来实现,将 deque 容器转换为 queue 容器.当然,也可以利用其他合适的序列容器作为底层实现queue容器. 队列可以用线性表(list)或双向队列(deque)来实现(注意vector container不能用

C++ Primer 学习笔记_104_特殊工具与技术 --嵌套类

特殊工具与技术 --嵌套类 可以在另一个类内部(与后面所讲述的局部类不同,嵌套类是在类内部)定义一个类,这样的类是嵌套类,也称为嵌套类型.嵌套类最常用于定义执行类. 嵌套类是独立的类,基本上与它们的外围类不相关,因此,外围类和嵌套类的对象是互相独立的.嵌套类型的对象不具备外围类所定义的成员,同样,外围类的成员也不具备嵌套类所定义的成员. 嵌套类的名字在其外围类的作用域中可见,但在其他类作用域或定义外围类的作用域中不可见.嵌套类的名字将不会与另一作用域中声明的名字冲突 嵌套类可以具有与非嵌套类相同

Python 库大全

作者:Lingfeng Ai链接:http://www.zhihu.com/question/24590883/answer/92420471来源:知乎著作权归作者所有.商业转载请联系作者获得授权,非商业转载请注明出处. Awesome Python中文版来啦! 本文由 伯乐在线 - 艾凌风 翻译,Namco 校稿.未经许可,禁止转载!英文出处:github.com.欢迎加入翻译组. 原文链接:Python 资源大全 1200+收藏,600+赞,别只顾着自己私藏呀朋友们 ------------