1.4 猫狗队列

题目：宠物、狗和猫的类如下：

 1 public class Pet
 2 {
 3     private String type;
 4     
 5     public Pet(String type)
 6     {
 7         this.type = type;
 8     }
 9 }
10 
11 public class Dog extends Pet
12 {
13     public Dog()
14     {
15         super("dog");
16     }
17 }
18 
19 public class Cat extends Pet
20 {
21     public Cat()
22     {
23         super("cat");
24     }
25 }

实现一种猫狗队列的结构，要求如下：

<1>用户可以调用add方法将cat类或dog类的实例放入队列中；

<2>用户可以调用pollAll方法，将队列中所有的实例按照进队列的先后顺序依次弹出；

<3>用户可以调用pollDog方法，将队列中dog类的实例按照进队列的先后顺序依次弹出；

<4>用户可以调用pollCat方法，将队列中cat类的实例按照进队列的先后顺序依次弹出；

<5>用户可以调用isEmpty方法，检查队列中是否还有dog或cat的实例；

<6>用户可以调用isDogEmpty方法，检查队列中是否有dog类的实例；

<7>用户可以调用isCatEmpty方法，检查队列中是否还有cat类的实例。

  1 class Pet
  2 {
  3     private:
  4         string type;
  5     public:
  6         Pet(string type_)
  7         {
  8             type = type_;
  9         } 
 10         
 11         Pet(){}
 12         
 13         string getPetType()
 14         {
 15             return type;
 16         }
 17 };
 18 
 19 class Dog : public Pet
 20 {
 21     public:
 22         Dog(string pet_ = "dog"): Pet(pet_)
 23         {
 24         
 25         }
 26 };
 27 
 28 class Cat : public Pet
 29 {
 30     public:
 31         Cat(string pet_ = "cat") : Pet(pet_)
 32         {
 33         
 34         }
 35 };
 36 
 37 class enterqueuetype              //队列的数据类型 
 38 {
 39     private:                     //包含两个数据成员 
 40         Pet pet;                 //宠物成员 
 41         int count;               //用来计数的成员 
 42     public:
 43         enterqueuetype(Pet pet_, int count_)
 44         {
 45             pet = pet_;
 46             count = count_;
 47         }
 48         
 49         enterqueuetype()
 50         {
 51             pet = Pet("no pet");
 52             count = 0;
 53         }
 54         
 55         Pet getpet()
 56         {
 57             return pet;
 58         }
 59         
 60         int getcount()
 61         {
 62             return count;
 63         }
 64         
 65         string getenterpettype()
 66         {
 67             return pet.getPetType();
 68         }
 69 };
 70 
 71 class catdogqueue                           
 72 {
 73     private:
 74         queue<enterqueuetype> dogq;      //狗队列 
 75         queue<enterqueuetype> catq;      //猫队列 
 76         int count;                       //用来标记猫狗入队的先后顺序 
 77     public:
 78         catdogqueue()
 79         {
 80             count = 0;
 81         }
 82         
 83         void add(Pet pet)
 84         {
 85             if(pet.getPetType().compare("dog") == 0)
 86             {
 87             
 88                 dogq.push(enterqueuetype(pet, count++));
 89             }
 90             else if(pet.getPetType().compare("cat") == 0)
 91             {
 92                 
 93                 catq.push(enterqueuetype(pet, count++));
 94             }            
 95         }
 96         
 97         void pollAll()
 98         {
 99             enterqueuetype cat;      
100             enterqueuetype dog;
101             
102             while(!dogq.empty() || !catq.empty())
103             {                
104                 if(!dogq.empty() && !catq.empty())
105                 {
106                     dog = dogq.front();
107                     cat = catq.front();
108                     if(dogq.front().getcount() < catq.front().getcount())
109                     {
110                         dogq.pop();
111                         cout << dog.getpet().getPetType() << endl;
112                     }
113                     else
114                     {
115                         catq.pop();
116                         cout << cat.getpet().getPetType() << endl;
117                     }
118                 }
119                 else if(!dogq.empty())
120                 {
121                     dog = dogq.front();
122                     dogq.pop();
123                     cout << dog.getpet().getPetType() << endl;
124                 }
125                 else if(!catq.empty())
126                 {
127                     cat = catq.front();
128                     catq.pop();
129                     cout << cat.getpet().getPetType() << endl;
130                 }
131             }
132         }
133         
134         Pet pollDog()
135         {
136             enterqueuetype dog;
137             dog = dogq.front();    
138             
139             if(!isDogEmpty())
140             {
141                 dogq.pop();
142                 return dog.getpet(); 
143             }
144         }
145         
146         Pet pollCat()
147         {
148             enterqueuetype cat;
149             cat = catq.front();
150             
151             if(!isCatEmpty())
152             {
153                 catq.pop();
154                 return cat.getpet();
155             }
156         }
157         
158         bool isEmpty()
159         {
160             return dogq.empty() && catq.empty();
161         }
162         
163         bool isDogEmpty()
164         {
165             return dogq.empty();
166         }
167         
168         bool isCatEmpty()
169         {
170             return catq.empty();
171         }
172 };