new、delete、以及queue类

本来以为很容易的,结果还是写了我两个小时。
用指针模拟queue类,再加上类,各种错误,总算是解决掉了--
#include<iostream>
#include<cstdlib>
#include<string>
using namespace std;
class Item
{
private:
    int time;
    int cost;
public:
    Item():time(0),cost(0){}
    Item(int k):time(k)
    {
        cost=rand()%3;
    }
    Item (const Item &st)
    {
        time=st.time;
        cost=st.cost;
    }
    Item &operator=(const Item &st)
    {
        time=st.time;
        cost=st.cost;
        return *this;
    }
    int dealt()
    {
        return time;
    }
    int dealc()
    {
        //cout<<"------"<<cost<<endl;
        return cost;

    }
    friend ostream &operator<<(ostream &os,Item &st)
    {
        os<<st.time<<endl<<st.cost;
        return os;
    }
};
struct ss
{
    Item num;
    struct ss *next;
};
class Queue
{
private:
    struct ss *beg,*end;
    int cnt;
    int tolt;
    int size;
    int xx;
public:
    Queue():beg(NULL),end(NULL),cnt(0),tolt(0),size(10),xx(0){};
    Queue(const Queue &st)
    {
        cnt=st.cnt;
        tolt=st.tolt;
        size=st.size;
        while(beg!=NULL)
        {
            ss *p=beg->next;
            delete beg;
            beg=p;
        }
        end=NULL;
        ss *p=st.beg;
        beg=new ss;
        beg->next=NULL;
        beg->num=p->num;
        end=beg;
        while(p->next!=NULL)
        {
            p=p->next;
            ss *p1=new ss;
            p1->num=p->num;
            p1->next=NULL;
            end->next=p1;
            end=p1;
        }
        //return *this;
    }
    Queue &operator=(const Queue &st)
    {
        cnt=st.cnt;
        tolt=st.tolt;
        size=st.size;
        while(beg!=NULL)
        {
            ss *p=beg->next;
            delete beg;
            beg=p;
        }
        end=NULL;
        ss *p=st.beg;
        beg=new ss;
        beg->next=NULL;
        beg->num=p->num;
        end=beg;
        while(p->next!=NULL)
        {
            p=p->next;
            ss *p1=new ss;
            p1->num=p->num;
            p1->next=NULL;
            end->next=p1;
            end=p1;
        }
        return *this;
    }
    bool empty()
    {
        if(cnt==0) return true;
        else return false;
    }
    bool full()
    {
        if(cnt==size) return true;
        return false;
    }
    bool push(Item &st)
    {
        if(full()) return false;
        cnt++;
        if(beg==NULL)
        {
            ss *p=new ss;
            p->num=st;
            p->next=NULL;
            beg=end=p;
        }
        else
        {
            ss *p=new ss;
            p->num=st;
            p->next=NULL;
            beg->next=p;
            end=p;
        }
        //cout<<beg->num<<endl;
        return true;
    }
    bool pop()
    {
        if(empty()) return false;
        cnt--;
        xx++;
        if(tolt<beg->num.dealt())
        {
            tolt=beg->num.dealt()+beg->num.dealc();
        }
        else
        {
            tolt+=beg->num.dealc();
        }
        ss *p=beg->next;
        delete beg;
        beg=p;
        return true;
    }
    int top(int w)
    {
        int tmp=beg->num.dealt()+beg->num.dealc();
        //cout<<"---"<<beg->num.dealt()<<"   "<<beg->num.dealc()<<endl;
        if(tmp<=w) pop();
    }
    void deal(int n)
    {
        tolt-=n;
    }
    ~Queue()
    {
        while(beg!=NULL)
        {
            ss *p=beg->next;
            delete beg;
            beg=p;
        }
    }
    friend ostream &operator<<(ostream &os,const Queue &st)
    {
        os<<"处理花费的总时间(分钟):"<<st.tolt<<endl<<"处理了多少人:"<<st.xx<<endl;
        os<<"队列里面还有多少人:"<<st.cnt<<endl;
        return os;
    }
};
int main()
{
    Queue q;
    //int sum=1235;
    int n,m;
    cout<<"请输入n,m:";
    cin>>n>>m;
    if(n>m)
    {
        int tmp=n;
        n=m;
        m=n;
    }
    for(int i=n;i<=m;i++)
    {
        Item p(i);
        q.push(p);
        if(!q.empty())
        {
            q.top(i);
        }
    }
    q.deal(n);
    cout<<q;
    return 0;
}

  

时间: 2024-12-13 23:05:22

new、delete、以及queue类的相关文章

【C++】Stack类与Queue类学习

1.Stack类学习 1)建立stack<string> 2)调用push函数将数据压入栈中 3)调用size函数查看当前栈内元素数量 4)调用empty函数检测栈是否为空 5)如果不为空则不断调用pop函数将元素从栈中取出(后入先出) #include <iostream> #include <stack> using namespace std; int main() {     stack<string> stkNameList;     stkNam

C#常用的集合类型(ArrayList类、Stack类、Queue类、Hashtable类、SortedList类)

1.ArrayList类 ArrayList类主要用于对一个数组中的元素进行各种处理.在ArrayList中主要使用Add.Remove.RemoveAt.Insert四个方法对栈进行操作.Add方法用于将对象添加到 ArrayList 的结尾处:Remove方法用于从 ArrayList 中移除特定对象的第一个匹配项:RemoveAt方法用于移除 ArrayList 的指定索引处的元素:Insert方法用于将元素插入 ArrayList 的指定索引处. 示例 ArrayList的使用 示例将介

queue 类

一:普通队列 1.队列特征:先进先出,它只允许在一端(队尾)进行插入元素操作,在另一端(队头)进行删除元素操作 2. 存取类函数 front():用来取出queue中的队头元素,对应于front()函数. back():用来取出queue中的队尾元素,对应于back()函数. 操作类函数 push_back():用来向queue的队尾插入元素,对应于push()函数. pop_back():用来将queue中的队头元素删除,对应于pop()函数. 3.如果要使用queue类函数,需要使用以下指令

QT中的QQueue类、C++中的queue类

C++中的queue 实现一种先进先出的数据结构,是一个模板类 头文件 #include<queue> queue<int> Q; //定义一个int型队列 Q.empty(); //返回队列是否为空 Q.size(); //返回当前队列长度 Q.front(); //返回当前队列的第一个元素 Q.back(); //返回当前队列的最后一个元素 Q.push(); //在队列后面插入一个元素, 比如插入数字5: Q.push(5) Q.pop(); //从当前队列里,移出第一个元素

05 2 栈与队列 队列的实现及Queue类

1 class CQueue { 2 3 /// <summary> 4 /// 存储数据 5 /// </summary> 6 private ArrayList m_arrayList; 7 8 public CQueue() { 9 m_arrayList = new ArrayList(); 10 } 11 12 /// <summary> 13 /// 入队 14 /// </summary> 15 public void EnQueue(obje

Java实现Queue类

import java.util.Iterator; import java.util.NoSuchElementException; import java.util.Scanner; public class Queue<Item> implements Iterable<Item> { private int N; private Node<Item> first; private Node<Item> last; private static cla

c# Queue 类

原文地址:https://www.cnblogs.com/fanweisheng/p/11517689.html

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

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

C++ Primer 学习笔记_82_模板与泛型编程 --类模板成员[续2]

模板与泛型编程 --类模板成员[续2] 六.完整的Queue类 Queue的完整定义: template <typename Type> class Queue; template <typename Type> ostream &operator<<(ostream &,const Queue<Type> &); template <typename Type> class QueueItem { friend clas