Why would the conversion between derived* to base* fails with private inheritance?
Solution 1
$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
Solution 2
I suspect the problem is that you can't convert a derived pointer to a base pointer, as the inheritance is private.
Solution 3
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.
Solution 4
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.
Solution 5
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;
}
Comments
-
Bruce almost 2 years
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. -
Kiran Kumar almost 14 yearsYou meant
virtual void sid()
? Also you need the base class destructor to bevirtual
. -
ereOn almost 14 years@Naveen: Thanks. I was on my way to add the destructor ;) Also yes, the
private
was a typo. -
Windows programmer almost 14 yearsThe virtual destructor is a good idea. Putting virtual on the sid function is contrary to a stated goal of the original poster.
-
Bruce almost 14 years@WP: Can you please elaborate on your answer
-
Bruce almost 14 yearsWhy cant I do this? What are the implementation problems in this?
-
Bruce almost 14 yearsCan you kindly provide your reference.
-
Chubsdad almost 14 years@Bruce: Oh sorry, I forgot to mention that the references are from the draft standard N3000. I found that C++03 has some confusing statements to understand this concept. I will update my post accordingly
-
Alexander Rafferty almost 14 yearsYou know, I HATE it when people downvote, and don't leave a comment.
-
Klaim almost 14 yearsPrivate inheritance means that you don't want the base class interface to be accessible other code than the child class code.
-
Head Geek over 12 yearsI didn't down-vote this answer, but I think it's mistaken. I've seen compilers give warnings for hiding a base-class function with a derived-class one, but never an error.
-
User almost 12 yearsDidn't really feel like spending time interpreting Chubsdad's answer and this was exactly what I needed to know. Was missing a
public
statement on my derived class definition -
mwjohnson over 10 yearsSee Douglas Leeder's and ereOn's answers for human readable and quick solutions.