纯虚拟函数是早期绑定（编译时）还是后期绑定（运行时）？

Question

I see in various online resources that virtual functions are runtime bound.

However a pure virtual function must be implemented in a derived class. So, it doesn't make sense to me why a vtable would be needed in that scenario. Therefore I was wondering if a pure virtual function is bound at runtime or compile time.

If it is bound at runtime, is it just for the case that a pure virtual function has an implementation and the derived class calls the base implementation? What happens if no implementation is provided? Does the compiler then inline the implementation?

Answer 1

As you already found out, virtual functions are resolved at runtime. You need a vtable for this situation:

class Parent {
 public:
  virtual void pure() = 0;
};

class Child : public Parent {
 public:
  void pure() {}
};

void do_pure(Parent& x){
   x.pure();
}

int main(){
  do_pure(Child());
}

The Child() instance is cast to a Parent when it is passed to do_pure . The vtable is then required for the line x.pure() to be able to locate the memory adress of the implementation of pure() .

If Child wouldn't implement do_pure , this wouldn't compile, because the line x.pure() could only crash.

Answer 2

All virtual functions need to have late binding.

Imagine the following class hierarchy:

struct Base {
    virtual void foo() = 0;
    virtual ~Base() = default;
};

struct Child: public Base {
    void foo() override { std::cout << "I'm good!"; }
};

struct Grandchild: public Child {
    void foo() final { std::cout << "But I'm better!"; }
};

void fooCaller(const Base& b) {
    //Which foo() do I call here? Child::foo() or Grandchild::foo()?
    b.foo();
}

int main() {
    Grandchild g;
    fooCaller(g);
}

A virtual function remains virtual in all derived classes, which means you can override is anywhere you want (unless it's declared final at some point). Compiler cannot know which version will be in use.

In theory, if we have virtual void foo() = 0; in Base and void foo() final; in Child , compiler could notice that there is only one possible implementation of foo and optimize it out of the vtable, but I never heard about any compiler doing that.
And such use case kind of defeats the purpose of pure virtual functions.