C ++从基类派生的类中调用函数，而无需强制转换且没有虚拟方法

Question

I was recently asked this question in an interview:

#include <iostream>
class Base
{
public:
    void foo() { std::cout << "foo" << std::endl; }
};

class Derived : public Base
{
public:
    void bar() { std::cout << "bar" << std::endl; }
};

int main(int argc, const char *argv[])
{
    Base *p = new Derived;
    // additional code here
    return 0;
}

The conditions on the question were that the Base and Derived classes cannot be changed (for example changing the name of the methods, adding additional methods, or changing a method to virtual. A further restriction was that no type of cast could be used. The pointer p had to be used. Other than that, you could write any additional code, including as many classes as necessary to insure that the "bar()" method was called using the object pointed to by p.

Given that no casts were allowed, the only aswer I could come up with was an old-school one:

Derived *d;
memcpy(&d, &p, sizeof p);
d->bar();

Which is even worse than a cast. The interviewer berated me and told me I didn't have even the most basic knowledge of object hierarchy since I could not see the very obvious, trivial solution to the question.

I apologize if this question is a duplicate; I've seen other questions about accessing a method in a derived class from a base class, but in all cases I saw, the answer involved either a cast or modification to either of the classes.

He may be correct; I've been programming in C++ for over 15 years and I cannot see the solution. It could be I've never encountered it since I would use a cast in this situation: in this case, it would have to be a static_cast since there are no virtual methods (not even the destructor) which would allow the dynamic_vast to compile (it fails with a message: "'Base' is not a polymorphic type"

Answer 1

Simple and easy dumb:

#define Base Derived

just before main . (you can then call bar on it)

Answer 2

I maybe would come up with something like:

void foobar(Base* b){
   Derived d;
   d.bar();    
}

int main(int argc, const char *argv[]){
    Base *p = new Derived;
    foobar(p);
    return 0;
}

And if the interviewer complains that this is too foobar, I would ask him to please ask less foobar questions :P

No, really, I do consider this as a valid answer to a quite academic question. I am using the object pointed by p (to call a foobar function) and I made sure that 'bar()' is called. I dont think such an exercise deserves a more sophisticated solution. Logically, my solution cannot be distinguished from whatever solution the interviewer had in mind.

Answer 3

The pointer p had to be used. Other than that, you could write any additional code, including as many classes as necessary to insure that the "bar()" method was called using the object pointed to by p.

As many classes as necessary, you say?

#include <iostream>

class Base
{
public:
    void foo() { std::cout << "foo" << std::endl; }
};

class Derived : public Base
{
public:
    void bar() { std::cout << "bar" << std::endl; }
};

int main()
{
    class Base
    {
    public:
        void bar() { std::cout << "bar" << std::endl; }
    };
    class Derived : public Base
    {
    };
    Base *p = new Derived;
    p->bar();
}

Answer 4

答案可能是：无法编译。

Answer 5

You could use a union for type-punning:

union {
    Base* bp;
    Derived* dp;
} my_union = {p};
my_union.dp->bar();