简单示例中的C++多态性

Question

我有这套类。

class Animal { 
public: 
    Animal(uint32_t attr1, uint32_t attr2); 

    virtual uint32_t get_attr1() const; 
    virtual uint32_t get_attr2() const; 

private: 
    uint32_t attr1; 
    uint32_t attr2; 
}; 

class Dog: public Animal { 
public: 
    Dog(uint32_t attr1, uint32_t attr2, uint32_t attr3); 
    uint32_t get_attr3() const; 

private: 
    uint32_t attr3; 
}; 

class Cat: public Animal { 
public: 
    Cat(uint32_t attr1, uint32_t attr2, uint32_t attr4); 
    uint32_t get_attr4() const; 

private: 
    uint32_t attr4; 
}; 

现在我想有一个声明

vector<Animal*> animals; 

和几个功能如下：

void f(Dog* dog); 
void f(Cat* cat); 

和验证码：

for (auto animal: animals) { 
    f(animal); 
} 

如何使多态性出这个代码？它看起来像动物不像猫或狗一样对待。

Answer 1

设置f()过载，将Animal*作为输入，然后您的for循环将按照您所写的那样工作。为了然后调用单独f()重载Dog和Cat，你将不得不在运行时使用dynamic_cast，如：

void f(Dog* dog) 
{ 
    // do something only a dog can do ... 
} 

void f(Cat* cat) 
{ 
    // do something only a cat can do ... 
} 

void f(Animal *animal) 
{ 
    if (Dog *dog = dynamic_cast<Dog*>(animal)) { 
     f(dog); 
    } 
    else if (Cat *cat = dynamic_cast<Cat*>(animal)) { 
     f(cat); 
    } 
} 

... 

for (auto animal: animals) { 
    f(animal); 
} 

然而，这不利于多态性的原则。如果f()需要做取决于它被称为上的Animal类型不同的东西，它应该是Animal类的虚方法，然后根据需要继承者可以覆盖它：

class Animal { 
public: 
    ... 
    virtual ~Animal() {} // <-- don't forget this! 
    ... 
    virtual void f() = 0; 
}; 

class Dog: public Animal { 
public: 
    ... 
    void f() override; 
}; 

class Cat: public Animal { 
public: 
    ... 
    void f() override; 
}; 

void Dog::f() 
{ 
    // do something only a dog can do ... 
} 

void Cat::f() 
{ 
    // do something only a cat can do ... 
} 

... 

for (auto animal: animals) { 
    animal->f(); 
}