[Daily]猫狗队列——”子类管理器“

【题目】

有猫狗类如下：

class Pet
{
    private:
        string m_type;
        
    public:
        Pet(string _type){ m_type=_type; }
        string GetPetType(){ return m_type; }
};

class Dog : public Pet
{
    public:
        Dog() : Pet("dog"){}
};

class Cat : public Pet
{
    public:
        Cat() : Pet("cat"){}    
};

要求实现如下功能：
- add：方法将cat类或dog类的实例放入队列
- pollAll : 将队列出队（按照队列的先后顺序）
- pollDog:将队列的dog类实例按照队列的先后顺序出队
- pollCat:同理
- isEmpty:队列是否为空
- isDogEmpty:检查队列是否存在dog类实例
- isCatEmpty:同理

【分析】

猫和狗两个类皆为Pet类的子类。很显然，最适合的方法就是利用两个队列来组合在同一个类里面。那么问题来了，如何在两个队列中确定总的入队顺序呢？
确定总入队顺序主要是为了满足 pollAll 方法的实现。
在书中明确指出了最好不要改变原本的猫狗类，因此我们可以将这两个类做一层包装。而数据类型用Pet来表示Cat 和 Dog，Pet作为统一的数据类型。
设计一个Tag时间戳来记录入队顺序即可

这里有一个问题：既然已经猫和狗既然被封装成同一个类型，为什么不直接用一个队列存储即可？
因为我们还要考虑到上述7种操作种，4种分别对类进行操作，如果只用以一个队列进行存储，复杂度将会大大提高。
这是很显然的，具体问题具体分析，本题考察的就是特殊数据结构的设计

【实现】

实现语言：C++
源代码

/*猫狗队列*/

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


class Pet
{
    private:
        string m_type;
        
    public:
        Pet(){}
        Pet(string _type){ m_type=_type; }
        string GetPetType(){ return m_type; }
};


class Dog : public Pet
{
    public:
        Dog() : Pet("dog"){}
};


class Cat : public Pet
{
    public:
        Cat() : Pet("cat"){}    
};

//将两个同父类的子类（Cat And Dog）包装起来
//方便用同种泛型的Queue包装起来 
class PetEnterQueue
{
    private:
        Pet m_pet;
        long m_count;    //这个类的最终目的：就是包装一个时间戳，以确定入队的顺序 
        
    public:
        PetEnterQueue(Pet _pet,long _count)
        {
            m_pet=_pet;
            m_count=_count;
        }
        
        Pet getPet() { return m_pet;}
        long getCount(){ return m_count;}
        string getType(){ return m_pet.GetPetType();}
}; 

//猫狗队列类
class CatAndDogQueue
{
    private:
        queue<PetEnterQueue> m_catQueue;  //猫队列 
        queue<PetEnterQueue> m_dogQueue;  //狗队列 
        long m_Count;                     //队列元素的个数
        
    public:
        CatAndDogQueue(){ m_Count=0; }    //构造函数中将容量设为0
        
        //主要操作函数
        
        //add：方法将cat类或dog类的实例放入队列
        void add(Pet pet)
        {
            if(pet.GetPetType()=="dog") //狗元素
                m_dogQueue.push(PetEnterQueue(pet,m_Count++)); 
            else if(pet.GetPetType()=="cat")
                m_catQueue.push(PetEnterQueue(pet,m_Count++));
            else
                cout<<"添加的元素类型有误，请检查！"<<endl;
        } 
        
        //pollAll : 将队列出队（按照队列的先后顺序）
        Pet pollAll()
        {
            Pet pet;
            if(!m_catQueue.empty()&&!m_dogQueue.empty())    //两个队列皆不为空时 
            {
                if(m_catQueue.front().getCount() > m_dogQueue.front().getCount())
                {
                    pet=m_dogQueue.front().getPet();
                    m_dogQueue.pop();
                }
                else
                {
                    pet=m_catQueue.front().getPet();
                    m_catQueue.pop();
                }
            }
            else if(!m_dogQueue.empty()) 
            {
                pet=m_dogQueue.front().getPet();
                m_dogQueue.pop();
            }
            else if(!m_catQueue.empty())
            {
                pet=m_catQueue.front().getPet();
                m_catQueue.pop();
            }
            else
            {
                cout<<"当前队列为空队，无法出队！"<<endl;
                return pet; 
            }
            
            return pet; 
        }
        
        //pollDog:将队列的dog类实例按照队列的先后顺序出队 
        Pet pollDog()
        {
            Pet pet;
            if(m_dogQueue.empty())
            {
                cout<<"狗队为空，无法出队"<<endl;
                return pet;
            }
            pet=m_dogQueue.front().getPet();
            m_dogQueue.pop();
            return pet;
        } 
        
        //pollCat:同理
        Pet pollCat()
        {
            Pet pet;
            if(m_catQueue.empty())
            {
                cout<<"猫队为空，无法出队"<<endl;
            }
            pet=m_catQueue.front().getPet();
            m_catQueue.pop();
            return pet;
        }
        
        //isEmpty:队列是否为空
        bool isEmpty()
        {
            return m_dogQueue.empty()&&m_catQueue.empty(); 
        } 
        
        //isDogEmpty:检查队列是否存在dog类实例
        bool isDogEmpty()
        {
            return m_dogQueue.empty();
        }
        
        //isCatEmpty:同理
        bool isCatEmpty()
        {
            return m_catQueue.empty();
        }   
        
        void ShowCount()
        {
            cout<<"dog count : "<<m_dogQueue.size()<<endl;
            cout<<"cat count : "<<m_catQueue.size()<<endl;
            //cout<<"合计      : "<< m_dogQueue.size()+m_catQueue.size()<<endl;
        }   
};

【此外】

"子类管理器"，顾名思义，它可以很好的管理同一个父类的不同子类的集合。这可以延申到其他数据结构中
在C++中，子类实例转化为父类实例（在我印象中，这是没有的，也是不提倡的）。而Java上可以强制类型转换。因此，在pollCat()等方法中也可以返回子类类型，上述C++我直接返回Pet（父类类型）
可以直接父类实例给子类实例进行赋值(在编写代码时没有想到这一点)

Pet pet;
Dog dog;
Pet *pPet=&dog;
*pPet=pet;     //赋值成功

[Daily]猫狗队列——”子类管理器“

猜你喜欢