why can a base pointer point to derived object only under public inheritance?

Question

I think its because the base class data members and methods wont be accessible , but I\'d like some more clarity on this. Also, is this the reason why polymorphism (using vi

Answer 1

If I'm right, you are asking about the elements visibility inside a class. As you stated public/protected/private will influence the accessibility of your members/functions members/methods. (see Difference between private, public, and protected inheritance) However polymorphism is not restricted to public inheritance.

example:

class B
{
    protected:
        virtual void do_B() = 0;
};

class A : protected B
{
    virtual void do_B() {};
};

Answer 2

Here is an example which will help you to understand better

class Base{
  public:
  int foo;
};
class Derived: private Base{
  public:
  int bar;
};

Now in this program lets see what the derived class object can do. The derived class object can

• Access the integer variable bar publicly.
• Access the integer variable foo privately (only inside the class Derived) because the relation of inheritance is private.

Now lets see what happens if a Base pointer can do if it is made to point to such object. For the base class pointer,

• The Base pointer can't access the variable bar because it only points to the base section of the derived class object.
• And according to the base class pointer the variable foo is public, As it has been defined under the base class that it is public.

So now you can see the ambiguity that the base pointer will face if it points to an object of a class inherited under private relation.

Ambiguity: According to the derived class object foo is private, but the base pointer considers it to be public.

So the morale of private or protected inheritance is lost if such things were allowed. I hope this clears your doubt.

Answer 3

Actually, a pointer to base can point to a derived class even if the base is private. The thing is that such a conversion is impossible from outside the class. However, it's still possible to perfrom such a conversion in a context where the base is accessible.

Example:

#include <iostream>
using namespace std;

struct Base
{
    void foo() const {
        cout << "Base::foo()\n";
    }
};

struct Derived : private Base
{
    const Base* get() const {
        return this; // This is fine
    }
};

int main()
{
    Derived d;
    const Base *b = &d; // This is illegal
    const Base *b = d.get(); //This is fine
    b->foo();
}

Live example

Live example with virtual call