0

Why this is not legal:

class Base
{
public:
    Base(){};
    virtual ~Base(){};
};

class Derived : public Base{};

void takeDerived(Derived * c){};

// main
void(*ptr)(Base*) = static_cast<void(*)(Base*)>(&takeDerived); // doesn't work

// but this work ok, as well as reinterpret_cast
// void(*ptr)(Base*) = (void(*)(Base*))(&takeDerived);

Derived is a Base. Why can't it be casted in function parameter? For example, I can do this easily even without casting:

void takeBase(Base* c){};
takeBase(new Derived{});
iBug
  • 35,554
  • 7
  • 89
  • 134
nikitablack
  • 4,359
  • 2
  • 35
  • 68
  • 1
    That would violate basic sanity. `takeDerived` expects a `Derived *`, but your `ptr` would accept *any* `Base`-derived pointer! – Kerrek SB Nov 25 '14 at 16:59

2 Answers2

1

It's just designed to be that way. A Base isn't a Derived. The is-a relationship for class derivation can't be reversed.

The type of a function parameter means "accept", while the type of an object means "fit". Casting the type of a function changes what it accepts. It's dangerous to allow a function to accept whatever isn't what it originally accepts.

Consider this code:

class Base {};
class Derived : public Base {
    public:
    int t;
    void useDerived() {}
};

void useDerived(Derived *d){
    d->useDerived();
}

What should happen if a Base object is passed?

Base b;
((void(*)(Base*))useDerived) (&b);

Even worse, what if another derivation of Base is passed?

class AnotherDerived : public Base {
    public:
    double t;
    void useDerived() {}
};
AnotherDerived ad;
((void(*)(Base*))useDerived) (&ad);
iBug
  • 35,554
  • 7
  • 89
  • 134
0

Yes, but you're trying to do it the other way around. You cannot do

void takeDerived(Derived *c) { }

...

Base b;
takeDerived(&b);

The function pointer cast you're trying to do would enable these shenanigans; you could do

void (*ptr)(Base*) = takeDerived;
Base b;
ptr(&b); // Oops.

Then things would explode, and that would be bad.

seldon
  • 510
  • 2
  • 4