首页 > 代码库 > C++父子类继承时的隐藏、覆盖、重载

C++父子类继承时的隐藏、覆盖、重载

  存在父子类继承关系时,若有同名成员函数同时存在,会发生隐藏、覆盖和重载这几种情况。对于初学者也比较容易混淆,为此,我整理了一下我的个人看法,仅供参考。希望对大家理解有帮助,也欢迎指正。

1.父子类继承关系: 子类复制父类全部成员

  首先,理解父子类的继承关系是怎样发生的。在此基础上就很容易理解它们之间的关系和区别。  

  每一个类有它自己的成员变量和成员函数,是一个独立的空间整体。当子类继承父类时,会将父类的全部成员全部复制一份,作为子类的成员,但是,同时也会标记这些成员是从父类中继承的,与子类本身的成员,还是有区别的。这里认为将子类本身的成员存在子类域,从父类复制过来的存在父类域。

如下图,Childer类中存在两个域,子类域和父类域,相互之间互不干扰。

 

 1 class Father 2 { 3     int f_a; 4     int f_b; 5 }; 6  7 class Childer:public Father 8 { 9     int c_a;10     int f_b;11 };12 13 int main()14 {15     cout<<"sizeof childer:"<<sizeof(Childer)<<endl;   //-> 1616     cout<<"sizeof father:"<<sizeof(Father)<<endl;     //-> 817 }

 运行结果显示,子类大小为16,父类大小为8,也就是说子类的确有4个成员变量,就算是同名成员,也同样复制。

 

 

2.隐藏:子类对象优先考虑子类域自身成员(成员变量和成员函数)

   隐藏发生的主要原因,就是当子类有父类的同名成员时,子类对象访问该成员时,会发生冲突。所以编译器的处理方式是,优先考虑子类域中的自身成员。

即,子类对象访问某成员时,如ch.m_m 或者ch.f(),成员变量和成员函数都一样。编译器首先在子类域中检索,如果在子类域中找到该成员,则检索结束,返回该成员进行访问。如果在子类域中找不到该成员,则去父类域中检索。如果父类域中存在,则返回该成员进行访问,如果父类域中也不存在,则编译错误,该成员无效。

  当父子类域都存在同一成员时,编译器优先在子类中检索,就算父类域中也存在该同名成员,也不会被检索到。因此,父类域中的该成员被子类域中的该同名成员隐藏,即访问时完全以为该成员不存在,如果想访问父类域中的该成员,只能通过显示调用的方式,即:ch.Father::m_m;

        

 下面用代码说明,为了对问题有针对性说明,此处成员都采用public,也不涉及构造析构等问题。

 1 class Father 2 { 3 public: 4     int f_a; 5     int f_b; 6  7     void ff1() {cout<<"father ff1"<<endl;} 8 }; 9 10 class Childer:public Father11 {12 public:13     int c_a;14     int f_b;15 16     void cf1() {cout<<"childer cf1"<<endl;}17     void ff1() {cout<<"childer ff1"<<endl;}18 };19 20 int main()21 {22     Childer ch;23     24     cout<<ch.c_a<<endl; //只在子类域中的成员变量25     cout<<ch.f_b<<endl; //子类域和父类域都存在,优先访问子类域中的26     cout<<ch.Father::f_b<<endl; //显示访问被隐藏的成员变量27 28     cout<<"====================\n";29     30     ch.cf1();31     ch.ff1();32     ch.Father::ff1();33 }

 

 运行结果可以看出,ch.f_b;  和 ch.Father::f_b;  两个同名成员同时存在。但访问时,子类成员将父类成员隐藏,想访问父类成员只能显示调用。

通过成员函数的访问,这一效果更明显,ch.ff1();调用时,调用了子类域中的该同名成员函数。

  且此时编译器检索时,只根据名字,与函数的参数和返回类型无关。

1 int ff1(int a ) {cout<<"childer ff1"<<endl;return 0;}

若将Childer中的函数,改为上述类型。主函数中调用时,ch.ff1();编译错误。因为子类的int ff1(int a);会将父类的void ff1();隐藏。所以它们之间不存在重载。

应该改为 ch.ff1(10); 这样会匹配子类域中的该成员。或者ch.Father::ff1();显示调用父类域中的成员。

 

3.覆盖:虚函数,成员函数类型一摸一样,父类指针调用子类对象成员

 覆盖只发生在有虚函数的情况下,且父子类成员函数类型必须一摸一样,即参数和返回类型都必须一致。子类对象调用时,会直接调用子类域中的成员函数,父类域中的该同名成员就像不存在一样,(可以显示调用)即父类该成员被子类成员覆盖。这里很多人会感觉疑惑,认为是隐藏,因为父类的成员函数依然存在,依然可以调用,只是优先调用子类的,也就是“隐藏”了。而“覆盖”两个字的意思,应该是一个将另一个替代了,也就是另一个不存在了。

  举个小例子可以很明显的看出,覆盖的情况下,父子类的成员函数也是同时存在的。

virtual void ff1() {cout<<"father ff1"<<endl; }

将上面的例子Father类中的ff1函数加上virtual,其他不进行改变,运行结果也不变。

 

  下面解释一下,“覆盖”二字的由来。

首先需明白一点,虚函数的提出,是为了实现多态。也就是说,虚函数的目的是为了,在用父类指针指向不同的子类对象时,调用虚函数,调用的是对应子类对象的成员函数,即可以自动识别具体子类对象。所以,上述例子中,直接用子类对象调用虚函数是没有意义的,一般情况也不会这样使用。

 1 class Father 2 { 3 public: 4     virtual void ff1() {cout<<"father ff1"<<endl;} 5 }; 6  7 class Childer_1:public Father 8 { 9 public:10     void ff1() {cout<<"childer_1 ff1 "<<endl;}11 };12 class Childer_2:public Father13 {14 public:15     void ff1() {cout<<"childer_2 ff1"<<endl; }16 };17 18 int main()19 {20     Father* fp;21 22     Childer_1 ch1;23     fp = &ch1;24     fp->ff1();25 26     Childer_2 ch2;27     fp = &ch2;28     fp->ff1();29     30     return 0;31 }

  使用虚函数,都是父类指针的形式,pf->f11() 。例子中的24行和28行,相同的代码,因为fp的指向不同对象,所以调用不同对象的虚函数。但从代码上看,fp是一个Father类的指针,但调用的是子类成员函数,就好像父类的成员被覆盖了一样。这就是覆盖一词的来源。

 

覆盖的情况下,子类虚函数必须与父类虚函数有相同的参数列表,否则认为是一个新的函数,与父类的该同名函数没有关系。但不可以认为两个函数构成重载。因为两个函数在不同的域中。

 举例:

 1 class Father 2 { 3 public: 4     virtual void ff1() {cout<<"father ff1"<<endl;} 5 }; 6  7 class Childer_1:public Father 8 { 9 public:10     void ff1(int a) {cout<<"childer_1 ff1 "<<endl; }11 };12 13 int main()14 {15     Father* fp;16 17     Childer_1 ch1;18     fp = &ch1;19     fp->ff1();20    //ch1.ff1(); //没有匹配的成员21     ch1.ff1(2);22 23     return 0;24 }

运行结果为:

father ff1childer_1 ff1

从19行 fp->ff1();的运行结果可以看出,fp虽然指向子类对象,并且调用的是虚函数。但是该虚函数,在子类中没有对应的实现,只好使用父类的该成员。

即第10行的带参ff1 并没有覆盖从父类中继承的无参ff1. 而是认为是一个新函数。

 

4.重载:相同域的同名不同参函数

  重载必须是发生在同一个域中的两个同名不同形参之间的。如果一个在父类域一个在子类域,是不会存在重载的,属于隐藏的情况。调用时,只会在子类域中搜索,如果形参不符合,会认为没有该函数,而不会去父类域中搜索。

 

5.总结

  重载是在同一域下的函数关系,在父子类情况下时,一般不予考虑。

  隐藏,是子类改写、重写了父类的代码。而覆盖认为,子类实现了父类的虚函数。父类的虚函数可以没有实现体,成为纯虚函数,等着子类去实现。而隐藏时,父类的函数也必须有实现体的。隐藏还是覆盖,只是说法不同,只要明白编译器在调用时,如果检索、匹配相应的函数即可。

综上所述,总结为以下几点:

1.子类是将父类的所有成员都复制一份,并且保存在不同的域中。如果同名,子类中会有两份,分别在子类域和父类域。

2.调用时,是从调用对象(或指针)的类型开始检索的,先从自己域中检索,如果找到,判断是否为虚函数,不为虚函数直接调用,若为虚函数,通过运行时类型识别,调用真正对象的函数。如果没找到,去其父类域中检索,重复刚刚的判断。知道调用函数或者没有匹配的成员。

明白调用过程:

2.1  一般情况下,哪种类型的,就调哪种类型对于自己域中的成员。

Father f;   f.a; f.ff1(); 由于f是Father类型的,所以调用的都是Father自己域中的成员。

Childer c; c.a; c.ff1(); 由于c是Chiler类型的,所以调用的都是Childer自己域中的成员。

指针也一样。Father*fp;  fp->a;  fp->ff1();   由于fp是Father类型的指针,所以调用的都是Father自己域中的成员。

            就算fp = new Childer. fp->ff1(); 指向的是子类对象,依然调用父类自己的成员。因为fp是Father类型的。

                Childer *cp; cp->a; cp->ff1();   由于cp是Childer类型的指针,所以调用的都是Childer自己域中的成员。

2.2 .而有一种情况特殊,则是,当成员函数为虚函数时,虽然是父类类型的指针,但会根据指针指向的具体对象,调用该函数。
  即,如果ff1为虚函数,Father*fp; fp = new Childer; fp->ff1();   虽然fp是Father类型的指针,但由于ff1是虚函数,所以调用的是具体对象,Childer类的成员。

对比2中的相同语句,这就是虚函数和多态的意义。

 

C++父子类继承时的隐藏、覆盖、重载