您的位置:首页 > 其它

Inheritance: 'A' is an inaccessible base of 'B'

2012-09-24 16:37 771 查看
[code]简介:B PRIVATE/protected 继承A,那么 A 的指针不能指向B
分析:private表示派生类是更加严格的基类或者在某方面继承了基类。
它不遵守 Liskov substitution principle
[code]$ cat inheritance.cpp #include <iostream>using namespace std;class A { };class B : private A { };int main() {    A* ab = new B;}$$ g++ inheritance.cppinheritance.cpp: In function 'int main()':inheritance.cpp:9: error: 'A' is an inaccessible base of 'B'$
I just do not understand this error.As I understand, and as this tutorial confirms,
private
inheritance should only change how the members of
class B
are visible to the outside world.I think the private specifier is doing more than just change visibility of
class B
members here.What do I get this error and what does it mean?Basically what is wrong with allowing this type of code in C++? Looks totally harmless.c++ inheritance
share|improve this questionasked Mar 12 at 4:55Lazer9,340135614983% accept rate
feedback

5 Answers

activeoldestvotes
up vote6down voteacceptedBy making the inheritance private, you're basically saying that even the fact that B inherits from A (at all) is private -- not accessible/visible to the outside world.Without getting into a long-winded discussion of what would happen if it was allowed, the simple fact is that it's not allowed. If you want to use a pointer to base to refer to an object of derived type, then you're pretty much stuck with using public inheritance.Edit: Since somebody went to the trouble of sending an email to ask for more information about what could happen if this was allowed, I guess I'll elaborate a little on it.The basic problem is that private inheritance is not necessarily intended to follow the Liskov substitution principle. Public inheritance asserts that a derived object can be substituted for an object of the base class, and proper semantics will still result. Private inheritance does not assert that though. The usual description of the relationship implied by private inheritance is "is implemented in terms of".Public inheritance means a derived class maintains all the capabilities of the base class and potentially adds more besides. Private inheritance often means more or less the opposite: that the derived class uses a general base class to implement something with a more restricted interface.Just for example, let's assume for the moment that the containers in the C++ standard library were implemented using inheritance rather than templates. In the current system,
std::deque
and
std::vector
are containers, and
std::stack
is a container adapter that provides a more restricted interface. Since it is based on templates, you can use
std::stack
as an adapter for either
std::deque
or
std::vector
.If we wanted to provide essentially the same with inheritance, we would probably use private inheritance, so
std::stack
would be something like:
[code]class stack : private vector {    // ...};
In this case, we definitely do not want the user to be able to manipulate our
stack
as if it were a
vector
. Doing so could (and likely would) violate the expectations of a stack (e.g., the user could insert/remove items in the middle, rather than a purely stack-like fashion as intended). We're basically using
vector
as a convenient way to implement our stack, but if (for example) we changed the implementation for
stack
stand alone (with no dependence on a base class) or re-implement it in terms of
std::deque
, we do not want that to affect any client code -- to the client code, this is supposed to be just a stack, not some specialized variety of vector (or deque).
[code]原址:http://stackoverflow.com/questions/9661936/inheritance-a-is-an-inaccessible-base-of-b
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: 
相关文章推荐