派生指针

jy01807853 2012-04-24 03:57:38



class BASE

{

public:

        BASE(): aa(293) {}

        virtual void print() {cout<<"Hello\n";}

        virtual void set() {aa = 103;}

        int aa;



};



class Derived : private BASE  //换成protected也一样

{

public:

        //Derived(): BASE(103) {}

        BASE* pr(Derived* d)

        {

             return d;

        }

        void set(){aa=39;}

        void print(){;cout<<"World\n" << this->aa << endl;}

};



int main()

{

//BASE *p = new Derived;//为什么派生类的指针不能给基类

Derived dd;

BASE *p = dd.pr(new Derived); //这样就行，原先我理解。private继承，基类中的所有成员在派生类中为private访问

//编译器拒绝将 派生类的指针转换到基类。。是为了防止，用户调用在派生类中 已经是private基类的成员。。

//难道这不是派生类指针？



p->print();

cout << p->aa << endl;

p->set();

cout << p->aa;



}

...全文

138 10 打赏收藏转发到动态举报

写回复

用AI写文章

10 条回复

切换为时间正序

请发表友善的回复…

发表回复

evencoming 2012-04-26

打赏
举报

[Quote=引用 9 楼的回复:]
引用 8 楼的回复:

引用 7 楼 jy01807853 的回复:
我知道，只是想问，直接private继承的派生类指针，不能给，但是间接的可以。
其实二者不是等价能得到转换。

没听懂你这段话.

就是，，仍然有办法可以做到 private基类的派生类指针给基类指针
[/Quote]
这些只是简单的规则,让你遵守的.编译器没法太过于智能.
就像public和private, 你有N中方法去破坏,最简单的都可以#define private public..
难度高点的,直接重写虚表等.

jy01807853 2012-04-24

打赏
举报

[Quote=引用 8 楼的回复:]

引用 7 楼 jy01807853 的回复:
我知道，只是想问，直接private继承的派生类指针，不能给，但是间接的可以。
其实二者不是等价能得到转换。

没听懂你这段话.
[/Quote]

就是，，仍然有办法可以做到 private基类的派生类指针给基类指针

evencoming 2012-04-24

打赏
举报

[Quote=引用 7 楼 jy01807853 的回复:]
我知道，只是想问，直接private继承的派生类指针，不能给，但是间接的可以。
其实二者不是等价能得到转换。

[/Quote]
没听懂你这段话.

jy01807853 2012-04-24

打赏
举报

[Quote=引用 6 楼的回复:]

引用晨星的回复:
不管是什么继承，子类中都可以访问父类中所有public和protected的成员。
private继承只是表明继承关系是private的，而不表明所有成员的访问权限也是private的，这完全是两码事。
讲得通俗点，private继承是指“外界”不知道那个类还有个父类，而不是子类自己也不知道他有个父类。就像私有成员一样，外界不知道类有私有成员，不代表类自己也不了解自己……
[/Quote]
我知道，只是想问，直接private继承的派生类指针，不能给，但是间接的可以。
其实二者不是等价能得到 转换。

evencoming 2012-04-24

打赏
举报

[Quote=引用晨星的回复:]
不管是什么继承，子类中都可以访问父类中所有public和protected的成员。
private继承只是表明继承关系是private的，而不表明所有成员的访问权限也是private的，这完全是两码事。
讲得通俗点，private继承是指“外界”不知道那个类还有个父类，而不是子类自己也不知道他有个父类。就像私有成员一样，外界不知道类有私有成员，不代表类自己也不了解自己的私有成员。
[/Quote]



class A

{

public:

    A() {}

    int a;

};

class B:A

{

public:

    B() {}

    int geta(B *p)

    {

        //编译能通过,是因为B具有对A的成员a的访问权限.

        return p->a;

    }

};

int main()

{

  //  A *a=new B;//wrong

  //  int a=(new B)->a;//wrong ,和上面一样的错误

    int a=(new B)->geta(new B);// 和你那个能通过一样的道理.

//在 geta函数中, geta是B的成员函数.能够访问

}