More C++ Geekery.

[swestrup]

I hadn't realized until just now that dummy parameters were applied based on the static type of their function call. So this code:

struct Base
{
  virtual void f(int x=10)
    { cout << "Base: " << x << endl; }
};

struct Derived : public Base
{
  virtual void f(int x=20)
    { cout << "Derived: " << x << endl; }
};

int main()
{
  Base b;
  Derived d;
  Base *bp = &d;

  b.f();
  d.f();
  bp->f();
  return 0;
}


Has the surprising output of:

Base: 10
Derived: 20
Derived: 10


The last output is because the dummy parameter is supplied at the beginning of the call to bp->f() which has a static signature of void Base::f(int=10), even though virtual function resolution ends up with Derived::f() getting called.

I don't know that I will ever have reason to use this fact, but its yet one more gotcha in C++ that I hadn't known about.

Comments

[sps.livejournal.com]

There's a typo in the second call, right?

This is "the expected behaviour" because of a very early decision in C++ that functions do not have multiple entry points: the default parameter does not generate an overload. Without it doing that, it's not clear how else this could behave.

Not that it doesn't suck. The overload semantics would have been much more elegant.

[swestrup]

> There's a typo in the second call, right?

Oops, yeah. Now fixed.

And somehow, I'd always assumed that default parameters generated overloads. It would have been the more useful choice.

[pphaneuf.livejournal.com]

Default parameters are treacherous in many situations, especially when changing them around (think also of a compiled shared library user, ouch!). That's a good example. I prefer an inline overload, myself.