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

本文连接地址：http://hi.baidu.com/laoyang1018/blog/item/933d5243a75c3f1a9313c6db.html 

#######################

//声明： 1  本帖做者是：百变老羊 ，至此感谢！

              2  红色背景字体为我的阅读重点！

#######################

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

当一个子类从父类继承时，父类的全部成员成为子类的成员，此时对父类成员的访问状态由继承时使用的继承限定符决定。
1.若是子类从父类继承时使用的继承限定符是public，那么

(1)父类的public成员成为子类的public成员，容许类之外的代码访问这些成员；

(2)父类的private成员仍旧是父类的private成员，子类成员不能够访问这些成员；

(3)父类的protected成员成为子类的protected成员，只容许子类成员访问；

2.若是子类从父类继承时使用的继承限定符是private，那么

(1)父类的public成员成为子类的private成员，只容许子类成员访问；

(2)父类的private成员仍旧是父类的private成员，子类成员不能够访问这些成员；

(3)父类的protected成员成为子类的private成员，只容许子类成员访问；

3.若是子类从父类继承时使用的继承限定符是protected，那么

(1)父类的public成员成为子类的protected成员，只容许子类成员访问；

(2)父类的private成员仍旧是父类的private成员，子类成员不能够访问这些成员；

(3)父类的public成员成为子类的protected成员，只容许子类成员访问；

至于类中不一样成员(public、private和protected)的访问状态就不细说了。

c++访问权限和派生继承

在基类中，public表示成员是公有的：能够由程序中任何函数访问。因此公有成员通常是成员函数，它提供了外部程序与类的接口功能，用户经过公有成员访问该类对象中的数据。

private表示成员是私有的，只容许本类的成员函数和类的友元函数访问，任何外部程序对它访问都是非法的，全部它每每是用来描述该类对象属性的一些数据成员，是类中被隐藏的部分。

protect表示成员是受保护类型的，与私有成员在通常状况下含义相同，它们的区别是，在类的继承中对产生的新类影响不一样。

第一：private, public, protected 访问标号的访问范围。

private：只能由1.该类中的函数、2.其友元函数访问。

不能被任何其余访问，该类的对象也不能访问。

protected：能够被1.该类中的函数、2.其友元函数访问 3.子类的函数。

但不能被该类的对象访问。

public：能够被1.该类中的函数、2.其友元函数访问 3.子类的函数、也能够由4.该类的对象访问。

只有公有成员才能在类的外部访问。如
class A
{
private:
int a;
public:
int b;
protected:
int c;
};
A ca;
ca.a //error
ca.b // ok
ca.c //error

class B :public A
{
public:
int d;
}

B cb;
cb.b; //ok
cb.c //error。虽然c也是Ｂ的成员，但c在被继承的时候变成私有或者受保护的成员了。

注：友元函数包括3种：设为友元的普通的非成员函数；设为友元的其余类的成员函数；设为友元类中的全部成员函数。

派生类的生成过程：

class employee

{

protect:

char *name; //姓名

int individualEmpNo; //我的编号

int grade; //级别

float accumPay; //月薪总额

static int employeeNo; //本公司职员编号目前最大值

public:

employee();

~employee();

void pay(); //计算月薪函数

void promote(int); //升级函数

void displayStatus(); //显示人员信息

};

class technician:public employee

{

private:

float hourlyRate; //每小时酬金

int workHours; //当月工做时数

public:

technician(); //构造函数

void pay(); //计算月薪函数

void displayStatus(); //显示人员信息

}；

分析派生新类这个过程，其继承和派生机制的主要目的是实现代码的重用和扩充。实际是经历了三个步骤：吸取基类成员、改造基类成员、添加新的成员。

1.吸取基类成员

第一步是将基类的成员全盘接收：包含了它的全部基类中除构造和析构函数以外的全部成员。

这里派生类technician继承了基类employee的除构造和析构函数之外的全部成员：

name; individualEmpNo; grade; accumPay; employeeNo;

pay(); promote(int); displayStatus();

通过派生过程，这些成员便存在于派生类之中。

2.改造基类函数

对基类成员的改造包括两个方面，

一个是基类成员的访问控制问题，主要依靠派生类声明时的继承方式来控制：

类的继承方式：public、protected和private三种访问属性。 （见上）

第二个是对基类数据或函数成员的覆盖，

若是派生类声明了一个和某个基类成员同名的新成员（若是是成员函数，则参数表也要相同，

如pay(); displayStatus(); 参数不一样的状况属于重载）派生的新成员就覆盖了外层同名函数。这时，在派生类中或者经过派生类的对象直接使用成员名就只能访问到派生类中声明的同名成员，这称为同名覆盖。

3.添加新的成员

咱们能够根据实际状况的须要，给派生类添加适当的数据和函数成员，来实现必要的新增功能。如technician派生类中的hourlyRate和workHours，在派生过程当中，因为基类的构造函数和析构函数是不能被继承下来的，所以咱们就须要在派生类从新加入新的构造函数和析构函数来实现一些特别的初始化和清理工做，例如派生类technician的构造函数technician()；

第二：类的继承后方法属性变化。

特别的private，它们与派生类中新增长的private成员不一样，派生类函数或是创建派生类对象的模块都没法访问到它们。）（因此只能经过在派生类中调用基类的函数去访问private属性，也能够把基类的函数用public继承下来来访问）

private继承,父类的全部方法在子类中变为private;

protected继承,父类的protected和public方法在子类中变为protected,private方法不变;
public继承,父类中的方法属性不发生改变; 原来是怎样就怎样
public通常为函数和数据，protected和private通常只为数据。
public和protected在任何方式继承的状况下，也能被子类函数调用。

以下所示：

public: protected: private:
public继承 public（含继承下来的基类函数） protected 特别的private（用派生类对象访问时）能够

被public继承下来的基类函数直接调用
protected继承 protected protected 特别的private

protected ：不能被派生类对象直接调用，可间接被派生类函数和基类函数调用

特别的private:不能被派生类函数和派生类对象直接调用，（用派生类对象访问时） 只能从新定义：调用基类 由于private不能被子类函数访问

private继承 private private 特别的private

private:不能被派生类对象直接调用，1.可间接被派生类函数从新定义来调用。2.基类函数调用（用派生类对象访问时）只能从新定义：调用基类 由于public和protected能被子类函数访问

上面为一次继承的状况，如有些是没区别的，当时若是再继承的话就有区别了

继承下来的访问属性分为四种：

1.区分继承与访问， 特别的private为不能继承下来的，但能够访问

2.（ private）成员：包括从基类继承下来的非私有成员（私有继承时），以及派生类中新增长的私有成员，在派生类内部函数均可以访问到，但派生类对象不能访问。

3.（ protected）多是新增也多是从基类继承过来的，派生类内部成员函数能够访问，当派生类对象没法访问。

4.（public）成员：派生类成员函数和对象都能访问到

protected继承和private继承能下降访问权限。

当类的继承方式为public时，

基类的public和protected成员的访问属性在派生类中不变，而基类的private成员仍保持私有属性。

可得：派生类的其余成员函数和对象能够直接访问基类的公有成员和保护成员。

不管是派生类的成员，仍是派生类的对象都没法访问基类的私有成员。

其余外部使用者只能经过派生类的对象访问继承来的公有成员

公有public继承 特别性举例：

class vehicle

{

private:

int wheels;

protected:

float weight;

public:

vehicle(int in_wheels, float in_weight)

{  wheels=in_wheels;

weight=in_weight;

}

int get_wheels(){return wheels;}

float get_weight(){return weight;}

};

class car:public vehicle

{

private:

int passenger_load;

public:

car(int in_wheels,float in_weight,int people=5):vehicle(in_wheels,in_weight)

//这里不是调用基类构造函数，而是初始化赋值列表。

{ passenger_load=people;}

int get_passengers(){return passenger_load;}

};

void main()

{

car bluebird(4,1000);

cout<<"The message of bluebird(wheels,weight,passengers):"<<endl;

cout<<bluebird.get_wheels()<<","

<<bluebird.get_weight()<<","

<<bluebird.get_passengers()<<endl;

}

car public继承vehicle后，

private：wheels；

passenger_load；// 新增的

protected：weight；

public： vehicle不存在（派生类不继承基类的构造和析构函数）

get_wheels() //能够直接访问

get_weight() //能够直接访问

car

get_passengers   ;

保护protected继承

基类的public和protected成员都变为保护成员，而基类的private成员不可访问。

即基类中的保护成员只能被基类的成员函数或派生类的成员函数访问。

举例：

car protected继承verhicle后，

private：wheels；

passenger_load；// 新增的

protected：weight；

vehicle不存在（派生类不继承基类的构造和析构函数）

get_wheels()

get_weight()

public car

get_passengers ;

由于 get_wheels()  和 get_weight()被派生为protected，其只能被被1.该类中的函数、2.其友元函数访问 3.子类的函数。但不能被该类的对象访问。

因此要在派生类中使用对象访问，必须作一下修改：

class car:protected vehicle

{

private:

int passenger_load;

public:
car(int in_wheels,float in_weight,int people=5):vehicle(in_wheels,in_weight)

//这里不是调用基类构造函数，而是初始化赋值列表。

{ passenger_load=people;}

int get_wheels (){return vehicle::get_wheels();} //从新定义get_wheels ()

float get_weight(){return weight;} //从新定义get_weight()

int get_passengers(){return passenger_load;}
};

这里为了保证基类的部分外部接口特征可以在派生类中也存在，就必须在派生类中从新定义同名的成员函数 get_wheels()和get_weight()，根据同名覆盖的原则，在主函数中天然调用的是派生类的函数。

若是使用私有继承： 在该例子和protected同样。