Statically chosen function and virtual function

user_4175394 0
Viewed 86

Recently I've seen this C++ standard paragraph (http://eel.is/c++draft/expr.post#expr.call-5):

If the postfix-expression designates a destructor, the type of the function call expression is void; otherwise, the type of the function call expression is the return type of the statically chosen function (i.e., ignoring the virtual keyword), even if the type of the function actually called is different. This return type shall be an object type, a reference type or cv void.

I don't really understand this part:

the type of the function call expression is the return type of the statically chosen function (i.e., ignoring the virtual keyword), even if the type of the function actually called is different.

  1. What is the statically chosen function here?
  2. How virtual function can be statically chosen? I've always thought that it's chosen at the runtime.

  3. even if the type of the function actually called is different.

How a call expression can actually call function of the different type that was chosen?

covariant-return-types language-lawyer virtual-functions static-typing c++
2 Answers

virtual functions can have covariant return type,

so with

struct Base
{
    virtual ~Base() = default;
    virtual Base* Clone() const { return new Base(*this); }
};

struct Derived : Base
{
    // covariant return type:
    Derived* Clone() const override { return new Derived(*this); }
};

Then

Derived d;

Base& b = d;

auto* clonePtr = b.Clone(); // `auto` is `Base`, even if `Derived::Clone` is called.
                         // runtime type of `clonePtr` is `Derived`
std::unique_ptr<Base> clone(clonePtr); // Done in 2 steps for explanation
user_26845390

First, an example to illustrate.

struct B { 
  virtual B* f() { return this; }
};

struct D : B { 
  D* f() override { return this; }
};

void bar(B*) {}
void bar(D*) {}

int main() {
  D d;
  B& b = d;
  bar(b.f()); // calls `bar(B*)`
}

Here, the postfix expression b.f designates a function. It's B::f, and its return type is B*. Even though when overriding f the specified return type is covariant (D*). The fact the actual call is (supposedly) resolved at run-time doesn't change the fact we are choosing the function's identity statically. It's pertinent when there's also overloading involved. The same function name can designate two or more functions, and it's overload resolution that (statically) chooses which overload to call. That overload may be overriden in a derived class, but again its identity is static.

user_8176430
Related