所有继承同一个类的不同对象的单个容器

Question

我正在努力完成一些事情,但我不确定它是否可能.

快速的想法是,我正在写一个游戏,并希望有一个不同怪物的单个数组(或矢量).继承主类Monster的每个类都会简单地覆盖它的函数(但不添加任何新函数).

然后,当我浏览怪物列表时,我可以调用所有它们具有的相同功能.

这里有一些代码来展示我想要实现的目标:

class Monster
{
    public:
        int hp;  //hit points
        int atp; //attack power
        int def; //defense

        bool attacking;
        bool defending;

        virtual void attack();
        virtual void defend();
};

void Monster::attack()
{}

void Monster::defend()
{}



class Goblin: public Monster
{
    public:
        virtual void attack() override;
        virtual void defend() override;
};

void Goblin::attack()
{
    //Goblin's attacking patterns
}

void Goblin::defend()
{
    //Goblin's defending patterns
}


class Orc: public Monster
{
    public:
        virtual void attack() override;
        virtual void defend() override;
};

void Orc::attack()
{
    //Orc's attacking patterns
}

void Orc::defend()
{
    //Orc's defending patterns
}




int main(void)
{
    //This is where I'm not sure what to do:

    //Initialize monsters.  Make some Goblins, some Orcs
    int num_monsters = 10;
    Monster* monster_list;
    monster_list = new Monster[num_monsters];

    for (int i = 0; i < num_monsters; i++)
    {
        int which = rand() % 2;
        switch (which)
        {
            case 0:  //Goblin
               monster_list[i] = new Goblin;                   
               break;
            case 1:  //Orc
               monster_list[i] = new Orc;                   
               break;
        }
    }

    bool quit = false;
    while (quit == false)
    {
        for (int i = 0; i < num_monsters; i++)
        {
            if (monster_list[i].attacking == true)
                monster_list[i].attack();
            if (monster_list[i].defending == true)
                monster_list[i].defend();                
        }
    }
}

希望这能说明我正在努力做的事情.我知道这不起作用,但我不确定如何使它工作.感谢您的任何建议!

Answer 1

您需要使用指向基类的指针向量.

std::vector<Monster*> monsters;

monsters.push_back(new FireDragon());
monsters.push_back(new IceDragon());

然后,您将能够遍历怪物矢量并调用常用方法.

for(auto monster = monsters.begin(); monster != monsters.end(); monster++)
{
    (*monster)->attack();
}

课程:

class Monster {
public:
    virtual ~Monster() {}
    virtual void attack() = 0;
};

class FireDragon : public Monster {
public:
    ~FireDragon();
    void attack()
    {
        std::cout << "Fire breath!" << std::endl;
    }
};

class IceDragon : public Monster {
public:
    ~IceDragon();
    void attack()
    {
        std::cout << "Ice breath!" << std::endl;
    }
};

作为旁注,请确保在派生类中创建虚拟析构函数,否则将调用基类的析构函数.

ETA:这是智能指针的实现:

/*
Use std::unique_ptr<Monster> if your implementation doesn't need to pass the
monster objects around
*/

std::vector<std::shared_ptr<Monster>> monsters;

/*
Use std::make_unique<FireDragon>() if using unique_ptr
*/

monsters.push_back(std::make_shared<FireDragon>());
monsters.push_back(std::make_shared<IceDragon>());

for(auto monster : monsters)
{
    monster->attack();
}