C++基类和派生类私有、保护、公有成员访问控制以及动态绑定、三种继承

原创 2017年03月01日 09:11:37

1.类的一个特征就是封装,public和private作用就是实现这一目的。所以:

用户代码(类外)可以访问public成员而不能访问private成员;private成员只能由类成员(类内)和友元访问。private不能被继承,不能被子类的成员函数访问。

2.类的另一个特征就是继承,protected的作用就是实现这一目的。所以:

protected成员可以被类成员和友元访问,也可以被派生类对象访问,不能被用户代码(类外)访问。

3,virtual函数

    在设计一个基类的时候,如果发现一个函数需要在派生类里有不同的表现,那么它就应该是虚的。
   从设计角度讲,出现在基类中的虚函数是接口,出现在派生类中的虚函数是接口的具体实现。通过
   这样的方法,就可以将对象的行为抽象化。即,虚函数在子类中被重新定义。


4.C++中的静态绑定和动态绑定

C++在面向对象编程中,存在着静态绑定和动态绑定的定义,本节即是主要讲述这两点区分。
我是在一个类的继承体系中分析的,因此下面所说的对象一般就是指一个类的实例。
首先我们需要明确几个名词定义:

  • 静态类型:对象在声明时采用的类型,在编译期既已确定;
  • 动态类型:通常是指一个指针或引用目前所指对象的类型,是在运行期决定的;
  • 静态绑定:绑定的是静态类型,所对应的函数或属性依赖于对象的静态类型,发生在编译期;
  • 动态绑定:绑定的是动态类型,所对应的函数或属性依赖于对象的动态类型,发生在运行期;

从上面的定义也可以看出,非虚函数一般都是静态绑定,而虚函数都是动态绑定(如此才可实现多态性)。
先看代码和运行结果:

复制代码
 1 class A
 2 {
 3 public:
 4     /*virtual*/ void func(){ std::cout << "A::func()\n"; }
 5 };
 6 class B : public A
 7 {
 8 public:
 9     void func(){ std::cout << "B::func()\n"; }
10 };
11 class C : public A
12 {
13 public:
14     void func(){ std::cout << "C::func()\n"; }
15 };
复制代码

下面逐步分析测试代码及结果,

1 C* pc = new C(); //pc的静态类型是它声明的类型C*,动态类型也是C*;
2 B* pb = new B(); //pb的静态类型和动态类型也都是B*;
3 A* pa = pc;      //pa的静态类型是它声明的类型A*,动态类型是pa所指向的对象pc的类型C*;
4 pa = pb;         //pa的动态类型可以更改,现在它的动态类型是B*,但其静态类型仍是声明时候的A*;
5 C *pnull = NULL; //pnull的静态类型是它声明的类型C*,没有动态类型,因为它指向了NULL;

如果明白上面代码的意思,请继续, 

1 pa->func();      //A::func() pa的静态类型永远都是A*,不管其指向的是哪个子类,都是直接调用A::func();
2 pc->func();      //C::func() pc的动、静态类型都是C*,因此调用C::func();
3 pnull->func();   //C::func() 不用奇怪为什么空指针也可以调用函数,因为这在编译期就确定了,和指针空不空没关系;

 如果注释掉类C中的func函数定义,其他不变,即

复制代码
1 class C : public A
2 {
3 };
4 
5 pa->func();      //A::func() 理由同上;
6 pc->func();      //A::func() pc在类C中找不到func的定义,因此到其基类中寻找;
7 pnull->func();   //A::func() 原因也解释过了;
复制代码

如果为A中的void func()函数添加virtual特性,其他不变,即

复制代码
1 class A
2 {
3 public:
4     virtual void func(){ std::cout << "A::func()\n"; }
5 };
6 
7 pa->func();      //B::func() 因为有了virtual虚函数特性,pa的动态类型指向B*,因此先在B中查找,找到后直接调用;
8 pc->func();      //C::func() pc的动、静态类型都是C*,因此也是先在C中查找;
9 pnull->func();   //空指针异常,因为是func是virtual函数,因此对func的调用只能等到运行期才能确定,然后才发现pnull是空指针;
复制代码

分析:
在上面的例子中,

1. 如果基类A中的func不是virtual函数,那么不论pa、pb、pc指向哪个子类对象,对func的调用都是在定义pa、pb、pc时的静态类型决定,早已在编译期确定了。

    同样的空指针也能够直接调用no-virtual函数而不报错(这也说明一定要做空指针检查啊!),因此静态绑定不能实现多态;

2. 如果func是虚函数,那所有的调用都要等到运行时根据其指向对象的类型才能确定,比起静态绑定自然是要有性能损失的,但是却能实现多态特性;

 本文代码里都是针对指针的情况来分析的,但是对于引用的情况同样适用。

至此总结一下静态绑定和动态绑定的区别
1. 静态绑定发生在编译期,动态绑定发生在运行期;

2. 对象的动态类型可以更改,但是静态类型无法更改;

3. 要想实现动态,必须使用动态绑定;

4. 在继承体系中只有虚函数使用的是动态绑定,其他的全部是静态绑定;

 建议:

绝对不要重新定义继承而来的非虚(non-virtual)函数(《Effective C++ 第三版》条款36),因为这样导致函数调用由对象声明时的静态类型确定了,而和对象本身脱离了关系,没有多态,也这将给程序留下不可预知的隐患和莫名其妙的BUG;

 

另外,在动态绑定也即在virtual函数中,要注意默认参数的使用。当缺省参数和virtual函数一起使用的时候一定要谨慎,不然出了问题怕是很难排查。
看下面的代码:

复制代码
 1 class E
 2 {
 3 public:
 4     virtual void func(int i = 0)
 5     { 
 6         std::cout << "E::func()\t"<< i <<"\n";
 7     }
 8 };
 9 class F : public E
10 {
11 public:
12     virtual void func(int i = 1)
13     {
14         std::cout << "F::func()\t" << i <<"\n";
15     }
16 };
17 
18 void test2()
19 {
20     F* pf = new F();
21     E* pe = pf;
22     pf->func(); //F::func() 1  正常,就该如此;
23     pe->func(); //F::func() 0  哇哦,这是什么情况,调用了子类的函数,却使用了基类中参数的默认值!
24 }
复制代码

为什么会有这种情况,请看《Effective C++ 第三版》 条款37。
这里只给出建议:
绝对不要重新定义一个继承而来的virtual函数的缺省参数值,因为缺省参数值都是静态绑定(为了执行效率),而virtual函数却是动态绑定。

 

5,三种继承

C++对父类(也称基类)的继承有三种方式,分别为:public继承、protected继承、private继承。三种继承方式的不同在于继承之后子类的成员函数的“可继承性质”。

在说三种继承方式导致的子类成员函数可继承性质改变之前,先说一下在定义类的成员(包括函数和属性)的时候,在其前面添加public 或 protected 或 private对成员的可继承性的影响。其中,public类型的成员,在被继承的时候,能直接被子类使用,注意,如果成员属性是public的话,子类则可直接调用该成员属性。例如:

  1. class A  // 父类  
  2. {  
  3. public:  
  4.       A();  
  5.       int size;  
  6. }  
  1. class B:public A   // 子类  
  2. {  
  3. public:  
  4.     change(const int x)  
  5.    {  
  6.       size = x;  
  7.     }  
  8. }  

我这里写了个很简单的例子,其中父类A具有一个public类型的成员函数A()和一个public类型的成员属性size(int)。因为size是public的,所以在A的子类B中,B的成员函数可以直接调用size进行修改。因为size也是B的属性并且是可见也是可修改的。

如果成员是protected的话,表明只有这个类的继承类(子女)或者友好的类(friend)能购使用(直接调用)这些成员,否则不能使用。然后private成员的话固然是只有自己本身这个类可用,对其他任何类都不可见,也不可用,引用百度百科上的一段话概括这三者就是:

1、public:public表明该数据成员、成员函数是对所有用户开放的,所有用户都可以直接进行调用

2、private:private表示私有,私有的意思就是除了class自己之外,任何人都不可以直接使用,私有财产神圣不可侵犯嘛,即便是子女,朋友,都不可以使用。

3、protected:protected对于子女、朋友来说,就是public的,可以自由使用,没有任何限制,而对于其他的外部class,protected就变成private。

好,下面进入正题,就是三种对父类的不同继承方式对子类可继承方式的影响:

(1)public继承:

不改变父类成员的继承性质(public、protected、private),也就是说,父类public的成员在子类中仍然是public的,父类protected的成员在子类中仍然是protected的。派生类的成员函数可以访问基类的,公有,保护成员,但是不能访问的她的私有成员。基类的私有和保护成员对对象是不可见的,对象只能直接访问基类的公有对象。

(2)protected继承:

父类public类型的成员在子类中变为protected性质,protected的被继承依然是protected的。

派生类的成员函数可以访问基类的,公有,保护成员,但是不能访问的她的私有成员。基类的私有和保护成员,公有成员对对象是不可见的。

(3)private继承:

父类所有成员在被子类中都变成或者保留为private性质的。

派生类的成员函数可以访问基类的,公有,保护成员,但是不能访问的她的私有成员。基类的私有和保护成员,公有成员对对象是不可见的。


C++继承时派生类的成员访问属性

公用(public):访问权限最高;除派生类外,外部函数也可以直接访问(无论是成员变量还是成员函数)。 私有(private):访问权限最低;只能是该类内部函数互相调用,派生类、外部函数都不能访...
  • zhang2531
  • zhang2531
  • 2016年03月31日 16:41
  • 902

关于继承,不同继承方式,对于派生类成员以及基类的可见性

通过继承机制,可以利用已有的数据类型来定义新的数据类型。所定义的新的数据类型不仅拥有新定义的成员,而且还同时拥有旧的成员。我们称已存在的用来派生新类的类为基类,又称为父类。由已存在的类派生出的新类称为...
  • zch501157081
  • zch501157081
  • 2014年11月24日 13:28
  • 1277

C++ 公有继承、保护继承、私有继承的区别

1)基类成员对派生类的可见性 1. 公有继承(public) :基类的公有成员和保护成员作为派生类的成员时,它们都保持原有的状态,而基类的私有成员仍然是私有的,不能被这个派生类的子类所访...
  • chlele0105
  • chlele0105
  • 2014年03月28日 17:05
  • 1506

C++中派生类对基类成员的三种访问规则

 C++中派生类对基类成员的访问形式主要有以下两种: 1、内部访问:由派生类中新增成员对基类继承来的成员的访问。 2、对象访问:在派生类外部,通过派生类的对象对从基类继承来的成员的访问。今天...
  • snowsnowsnow1991
  • snowsnowsnow1991
  • 2016年09月04日 11:22
  • 1236

继承后基类、派生类的访问属性

一、单继承与多继承(1)一个派生类只从一个基类派生,这称为单继承(single inheritance);(2)一个派生类有两个或多个基类的称为多重继承(multiple inheritance);(...
  • zhangchen1003
  • zhangchen1003
  • 2015年09月05日 22:28
  • 1124

C++ 公有继承、保护继承和私有继承中类成员的访问权限的控制

zz: http://blog.sina.com.cn/s/blog_b35e31b90101b6y7.html 为了防止连接失效,所以直接转过来备份了! 很多同学到现在仍然对访问权限不是很清楚,...
  • temanIU
  • temanIU
  • 2016年02月26日 16:21
  • 1388

C++中基类私有成员会被继承吗

1.派生类间接访问继承私有成员在类的继承中,类的私有成员在派生类中是“不可见“的,这种”不可见“是指在派生类的成员函数中,或者通过派生类的对象(指针,引用)不能直接访问它们。但是,不能直接访问并不代表...
  • K346K346
  • K346K346
  • 2015年11月05日 00:51
  • 5324

C++中 public和private派生类继承问题和访问权限问题

当一个子类从父类继承时,父类的所有成员成为子类的成员,此时对父类成员的访问状态由继承时使用的继承限定符决定。 1.如果子类从父类继承时使用的继承限定符是public,那么 (1)父类的public...
  • u011038411
  • u011038411
  • 2013年06月20日 13:12
  • 1012

C++三种继承方式下的访问权限控制

众所周知,C++类中的成员(函数/变量)拥有三种访问权限:        public:用该关键字修饰的成员表示公有成员,该成员不仅可以在类内可以被访问,在类外也是可以被访问的,是类对外提供的可访问接...
  • casky237
  • casky237
  • 2017年01月28日 17:11
  • 1618

C++如何在派生类成员函数内调用基类的成员函数(包括构造函数)

前段时间在实现一段代码的过程中遇到了几个
  • yums467
  • yums467
  • 2014年11月14日 17:53
  • 3172
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++基类和派生类私有、保护、公有成员访问控制以及动态绑定、三种继承
举报原因:
原因补充:

(最多只允许输入30个字)