派生关系中的二义性处理

1.  单继承时父类与子类间重名成员的处理

 

   单继承时父类与子类间成员重名时，按如下规定进行处理：对子类而言，不加类名限定时默认为是处理子类成员，而要访问父类重名成员时，则要通过类名限定。

 

#include <iostream.h>

class CB {

    public:

  int a;

  CB(int x){a=x;}

  void showa(){cout<<"Class CB -- a="<<a<<endl;}

}; 

classCD:public CB {

public:

  int a;    //与基类a同名

  CD(int x, int y):CB(x){a=y;}

  void showa(){  //与基类showa同名

  cout<<"Class CD -- a="<<a<<endl;

  }

  voidprint2a() {

  cout<<"a="<<a<<endl;   //子类a

  cout<<"CB::a="<<CB::a<<endl;   //父类a

  }

}; 

void main() {

  CB CBobj(12);

  CBobj.showa();

  CD CDobj(48, 999);

  CDobj.showa();  //子类的showa

  CDobj.CB::showa();  //父类的showa

  cout<<"CDobj.a="<<CDobj.a<<endl;

  cout<<"CDobj.CB::a="<<CDobj.CB::a<<endl; 

}

    程序执行后的显示结果如下：

Class CB -- a=12

Class CD -- a=999

Class CB -- a=48

CDobj.a=999

CDobj.CB::a=48 

       2.  多继承情况下二基类间重名成员的处理

 

      多继承情况下二基类间成员重名时，按如下方式进行处理：对子类而言，不加类名限定时默认为是处理子类成员，而要访问父类重名成员时，则要通过类名限定。

  

#include <iostream.h>

classCB1 {

public:

  int a;

  CB1(int x){a=x;}

  void showa(){ cout<<"ClassCB1 ==> a="<<a<<endl;}

}; 

class CB2 {

 public:

  inta;

  CB2(intx){a=x;}

  voidshowa(){cout<<"ClassCB2 ==> a="<<a<<endl;}

};

 

class CD:publicCB1,  public CB2 {

   public:

  inta;         //与二基类数据成员a同名

  CD(intx, inty, intz):CB1(x),CB2(y){a=z;}

void showa(){  //与二基类成员函数showa同名

     cout<<"ClassCD ==> a="<<a<<endl;

  }

  voidprint3a() {

  //显示出派生类的a及其二父类的重名成员a

  cout<<"a="<<a<<endl;

  cout<<"CB1::a="<<CB1::a<<endl;

  cout<<"CB2::a="<<CB2::a<<endl;

  }

};

void main() {

  CB1 CB1obj(11);

  CB1obj.showa();

  CD CDobj(101, 202,909);

  CDobj.showa();  //子类showa

  CDobj.CB1::showa();  //父类showa

  cout<<"CDobj.a="<<CDobj.a<<endl;

  cout<<"CDobj.CB2::a="<<CDobj.CB2::a<<endl;

}

 

    程序执行后的显示结果如下：

Class CB1 ==> a=11

Class CD ==> a=909

Class CB1 ==> a=101

CDobj.a=909

CDobj.CB2::a=202

     3.  多级混合继承(非虚拟继承)
     包含两个基类实例情况的处理

多级混合继承情况下，若类D从两条不同“路径”同时对类A进行了一般性继承（非虚拟继承）的话，则类D的对象中会同时包含着两个类A的实例。此时，对类D而言，要通过类名限定来指定访问两个类A实例中的哪一个。

多级混合继承情况下，若类D从两条不同“路径”同时对类A进行了一般性继承（非虚拟继承）的话，则类D的对象中会同时包含着两个类A的实例。此时，对类D而言，要通过类名限定来指定访问两个类A实例中的哪一个。

 

    本例的类间继承关系示例如下:

class A

class B : public A

class C : public A

class D : public B, public C

   存储结构示意:

( ( (A) B ) ( (A) C ) D ) 

上述多级混合继承关系应用例举:

      例1. 类A--人员类；  类B--学生类； 类C--助教类；类D--学生助教类。

      例2. 类A--人员类；  类B--学生类； 类C--工人类；类D--工人学生类。

      例3. 类A--家具类；  类B--沙发类； 类C--床类；   类D--沙发床类。

  

#include <iostream.h>

class A {

public:

  int a;

  A(int x){a=x;}

  void showall(){cout<<"a="<<a<<endl;}

}; 

class B:public A {

public:

  int b;

  B(int x):A(x-1){b=x;}

};

 

class C:public A {

public:

  int c;

  C(int x):A(x-1){c=x;}

};

classD:public B,public C {

public:

  int d;

  D(int x, inty, intz):B(x+1),C(y+2){d=z;}

  void showall() {

  cout<<"C::a="<<C::a<<endl;

     //在类D定义范围内，要通过类名限定来指定

    //访问两个类A实例中的哪一个

  cout<<"B::a="<<B::a<<endl;

  cout<<"b,c,d="<<b<<","<<c<<", "<<d<<endl;

     //b、c、d不重名，具有唯一性

  }

}; 

void main() {

  D Dobj(101, 202, 909); 

  Dobj.showall();

  cout<<"-------------------"<<endl;

  cout<<"Dobj.C::a="<<Dobj.C::a<<endl;

  //访问类D的从C继承而来的a

  cout<<"Dobj.B::a="<<Dobj.B::a<<endl;

}

    程序执行后的显示结果如下：

C::a=203

B::a=101

b,c,d=102, 204, 909

-------------------

Dobj.C::a=203

Dobj.B::a=101