指向C ++中派生类的基类指针

Question

#include <iostream>
using namespace std;

class A {
    public:
        A ();
        virtual ~A();
};

class B: protected A {
    public:
        virtual ~B ();
};

int main() {
    A* pb = new B;//A is inaccessable base of B
    return 0;
}

when I run the code above, it tells me A is inaccessable base of B, the pb is a pointer, which pointer to the B, what is the problem?

Answer 1

Class B derives from class A, but marks it as being protected. This means that only subclasses of B 'see' that B derives from A.

Since the main routine is not a subclass of B, it only sees B, not that B derives from A. Therefore, you can't cast a B-pointer to an A-pointer.

To solve it, change it to this:

class B: public A {
public:
    virtual ~B ();
};

Answer 2

B is protected inherited from A, thus only subclasses of B 'knows' it's an A. the static main() doesn't 'know' it, because it does not inherit from B.
you can access B as an A in this situation:

class C: B {
    void foo() {
        A* pb = new B;
    }
};

if you need it in the main, you would need to change B to public inherit from A

Answer 3

It's because you inherited from A with protected . Change it to public and you will get what you expected.

See the C++ FAQ section 24.5 here .

Answer 4

The problem is the protected inheritance. B is not an A. B has an A. See this FAQ for more details.

Answer 5

If you change

class B: protected A

to

class B: public A

does it work?

Answer 6

问题是您从A继承了protected B，因此不允许外部代码“知道” B从A继承。用public替换protected，并且代码应该编译。

Answer 7

Derive B from public A , not protected A :

class B: public A
{
public:
    virtual ~B ();
};

Answer 8

You're using protected inheritance. Protected, when applied to members, means that "derived classes can access, but external callers cannot". And when applied to inheritance, it means... exactly the same thing.

So within the B class, you know that it is derived from A , and can cast to an A* and back

BUt outside of B (for example, in the main function), the inheritance isn't visible, and so you can't convert a B* to A* .

Answer 9

#include <iostream>

using namespace std;

class A {
    public:
        A () {};
        virtual ~A();
};

class B: public A {
    public:
        B() {};
        virtual ~B ();
};

int main() {
    A* pb = new B;
    return 0;
}

This seems to work. In your example you make B ready for future inheritance, protected inherit makes A protected and only B methods can see the A.

Answer 10

The property of Inheritance rules out the possibility of derivation of a protected parent class into a subclass. Therefore, deriving the attributes of class A to class B isn't really going to happen in the code. Unless you change protected to public in line #10 , so that the protocols are followed, and the code looks like this:

class B: public A
{
public:
    virtual ~B ();
};