带有继承的编译器行为

Question

I have a question about the compiler behavior when I use up-casting in C++. For example I have this simple code:

class Animal {

public:
    Animal() {}

    void talk() {
        std::cout << "I am an animal" << std::endl;
    }
};

class Dog :public Animal {

public:
    Dog(){}

    void talk() {
        std::cout << "I am a dog" << std::endl;
    }

    void eat() {
        std::cout << "eating" << std::endl;
    }
}; 

int main()
{
    Animal* animal = new Dog();
    animal->talk();//Output is "I am an animal"
    //animal->eat();//Compilation error.
    return 0;
}

My question is, where does the compiler go first when I run this? Does it look for the methods in Animal class, and then because I didn't use virtual it calls for the Animal's talk() method, or does it checks if the method exists in the Dog class first, and calls for the Animal's method?

Answer 1

Given your code, animal->talk() will always call Animal::talk() . Because animal is a Animal * and Animal::talk() is not virtual.

Now if you make Animal::talk() virtual, animal->talk() will call Dog::talk() . Normally this is done by looking at run-time at the vtable of animal to see the real type of the object and then call the most appropriate talk() function. But since you have Animal *animal = new Dog() just above, the compiler can choose to optimize the call by skipping the vtable lookup and make a direct call to Dog::talk() as the type is already known at compile time.