Why would the conversion between derived* to base* fails with private inheritance?

Here is my code -

#include<iostream>
using namespace std;

class base
{
public:
    void sid()
    {
    }  
};

class derived : private base
{
public:
    void sid()
    {
    }
};

int main()
{
    base * ptr;
    ptr = new derived; // error: 'base' is an inaccessible base of 'derived'
    ptr->sid();
    return 0;
}

This gives a compile time error.

error: 'base' is an inaccessible base of 'derived'

Since the compiler will try and call the base class sid() why do I get this error? Can someone please explain this.

Chubsdad

$11.2/4 states-

A base class B of N is accessible at R, if

an invented public member of B would be a public member of N, or

R occurs in a member or friend of class N, and an invented public member of B would be a private or protected member of N, or

R occurs in a member or friend of a class P derived from N, and an invented public member of B would be a private or protected member of P, or

there exists a class S such that B is a base class of S accessible at R and S is a base class of N accessible at R."

Here 'B' is 'Base', 'N' is 'Derived' and 'R' is main.

Consider the 2nd bullet- 'R occurs in a member or friend of a class N,...'. This clause does not apply as 'R'(main) is neither a member nor friend of 'N'(Derived)
Consider the 3rd bullet- 'R occurs in a member or friend of a class P....'. This claus also does not apply for the same reasons as above
Consider the 4th bullet- Once again this clause does not apply

Thus we can conclude that 'Base' is not an accessible class of 'Derived'.

$11.2/5 states -

If a base class is accessible, one can implicitly convert a pointer to a derived class to a pointer to that base class (4.10, 4.11). [ Note: it follows that members and friends of a class X can implicitly convert an X* to a pointer to a private or protected immediate base class of X. —end note ]

Since Base is not an accessible class of Derived when accessed in main, the Standard conversion from Derived class to Base class is ill-formed. Hence the error.

EDIT 2:

Study the error messages of some popular compilers and that should help you get a better understanding. Note how the word 'inaccessible' pops up so frequently and consistently across all the error messages

The references are from the draft standard N3000. I am yet to download the latest draft :)

GCC prog.cpp: In function ‘int main()’: prog.cpp:27: error: ‘base’ is an inaccessible base of ‘derived’

Comeau Online "ComeauTest.c", line 26: error: conversion to inaccessible base class "base" is not allowed ptr = new derived;

VS2010 error C2243: 'type cast' : conversion from 'derived *' to 'base *' exists, but is inaccessible

I suspect the problem is that you can't convert a derived pointer to a base pointer, as the inheritance is private.

Chusbad provided an in-depth explanation involving the standard, I'll try to provide an accessible explanation.

In C++, there are 3 access level specifiers: public, protected and private. Those are meant to determine WHO can access methods, attributes or base classes. It is typical amongst Object Oriented languages.

Here, you elected private inheritance. Conceptually this means that you seek to HIDE the fact that Derived inherits from Base to outsiders, which generally means this is an implementation details.

As a consequence, the "exterior" is unaware of this relationship. This is enforced by the compiler with this inaccessible message.

From a design point of view, private inheritance is not generally required. Either the Liskov Substitution Principle applies and you use public inheritance, either it's an implementation detail and you use composition.

Windows programmer

You know that class derived inherits from class base, but the main() function doesn't know it. The reason the main() function doesn't know it is that you made class derived inherit PRIVATELY from class base.

Therefore when you try to assign new derived to ptr, the pointer types are not compatible.

Try this:

#include<iostream>
#include<conio.h>
using namespace std;

class base
{
      private:
      public:
          virtual void sid() // You might want to declare sid virtual
             {
                  cout<<"base";
             } 
          virtual ~base() // You then probably need a virtual destructor as well.
             {
             } 
};

class derived : public base //public inheritance
{
      private:
      public:
             void sid()
             {
                  cout<<"derived";
             }
};

int main()
{
    base * ptr;
    ptr = new derived;
    ptr->sid();
    getch();
    return 0;
}

this gives error C2243: 'type cast' : conversion from 'derived *' to 'base *' exists, but is inaccessible This derived class has been inherited privately .so base class object is not gets created when derieved get creation happens. to create the derive object first calls goes to create the base class object that not happening. soltuion is to derive the class publicly. it doesnit matter whether your using virtual keyword with member functions or not.

You need to declare your sid() function in the base class as virtual. A virtual function can be replaced by a derived class. Otherwise, you would likely get a compiler error.

来源：https://stackoverflow.com/questions/3674876/why-would-the-conversion-between-derived-to-base-fails-with-private-inheritanc

标签

c++

private

base

derived

accessible