c++问题请教

闪亮的马路

#include <iostream>
#include <string>

class Pet
{
public:
        Pet(std::string theName);

        void eat();
        void sleep();
        void play();

protected:
        std::string name;
};

class Cat : public Pet
{
public:
        Cat(std::string theName);

        void climb();
        void play();
};

class Dog : public Pet
{
public:
        Dog(std::string theName);

        void bark();
        void play();
};

Pet::Pet(std::string theName)
{
        name = theName;
}

void Pet::eat()
{
        std::cout << name << "正在吃东西!\n";
}

void Pet::sleep()
{
        std::cout << name << "正在睡大觉!\n";
}

void Pet::play()
{
        std::cout << name << "正在玩儿!\n";
}

Cat::Cat(std::string theName) : Pet(theName)
{
}

void Cat::climb()
{
        std::cout << name << "正在爬树!\n";
}

void Cat::play()
{
        Pet::play();
        std::cout << name << "玩毛线球!\n";
}

Dog::Dog(std::string theName) : Pet(theName)
{
}

void Dog::bark()
{
        std::cout << name << "旺~旺~\n";
}

void Dog::play()
{
        Pet::play();
        std::cout << name << "正在追赶那只该死的猫!\n";
}

int main()
{
        Pet *cat = new Cat("加菲");
        Pet *dog = new Dog("欧迪");

        cat -> sleep();
        cat -> eat();
        cat -> play();

        dog -> sleep();
        dog -> eat();
        dog -> play();

        delete cat;
        delete dog;

        return 0;
}
上面程序的运行结果是：
加菲正在睡大觉!
加菲正在吃东西!
加菲正在玩儿!
欧迪正在睡大觉!
欧迪正在吃东西!
欧迪正在玩儿!
这样的结果本来就是对的呀

看小甲鱼c++视频说，使用虚方法，然后Pet类的void play(); 修改成virtual void play(); 这样修改后的运行结果是：
加菲正在睡大觉!
加菲正在吃东西!
加菲正在玩儿!
加菲玩毛线球!
欧迪正在睡大觉!
欧迪正在吃东西!
欧迪正在玩儿!
欧迪正在追赶那只该死的猫!

如果把
        Pet *cat = new Cat("加菲");
        Pet *dog = new Dog("欧迪");
修改成
        Cat *cat = new Cat("加菲");
        Dog *dog = new Dog("欧迪");
运行后的结果也是
加菲正在睡大觉!
加菲正在吃东西!
加菲正在玩儿!
加菲玩毛线球!
欧迪正在睡大觉!
欧迪正在吃东西!
欧迪正在玩儿!
欧迪正在追赶那只该死的猫!

所以为什么非要用虚方法？

superbe

定义虚函数是为了实现动态绑定(多态性)，此时根据基类指针或引用”实际“指向的对象类型(基类还是子类)调用该对象的方法。这个小程序太小不容易体现出动态绑定的好处，利用多态性可以方便地实现集中控制。
举个简单的例子，假如有很多(1000只)动物，都要执行play方法该怎么办，不用动态绑定大概是这样的：
dog->play();
cat->play();
pig->play();
cock->play();
duck->play();
......等等等等

而用动态绑定呢，很简单，只要在创建动物时把它加入一个基类对象的数组Pet pets[1000]，然后一个循环搞定：
for(int i=0;i<1000;i++){
    pets[ i ].play();
}
每个动物就会执行它自己的play()方法。

只是按照我的解，举了个不太恰当的例子，如果不对还请大神指正。