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成员，只允许子类成员访问；

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继承verhicle后，

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一样