首先对于
非派生的情况:
类 访问 自身的公有成员、保护成员、私有成员,都是OK的。
类对象 访问 自身的公有成员是OK的。
类对象 访问 自身的保护成员是error的。
类对象 访问 自身的私有成员是error的。
然后对于
派生的情况:
一、公有继承方式(最常用):
public基类成员
保持
自己public访问级别,成为派生类的public成员。
protected基类成员
保持
自己的protected访问级别,成为派生类的protected成员。
private基类成员
依然是
基类自己的private成员,派生类是无法访问的。
二、私有继承方式:
public基类成员
成为
派生类的private成员。
protected基类成员
成为
派生类的private成员。
private基类成员
依然是
基类自己的private成员,派生类是无法访问的。
三、保护继承方式:
public基类成员
成为
派生类的protected成员。
protected基类成员
保持
成为
派生类的protected成员。
private基类成员
依然是
基类自己的private成员,派生类是无法访问的。
- #include<iostream>
- using namespace std;
- class base{
- public:
- base():base_pub(1),base_pro(2),base_pri(3) {}
- int base_pub;
- protected:
- int base_pro;
- private:
- int base_pri;
- public:
- int use_mypub() { return base_pub; }
- int use_myro() { return base_pro; }
- int use_mypri() { return base_pri; }
- };
- class pub_derive : public base {
- public:
- int use_base_pub()
- {
- return base_pub;
- }
- int use_base_pro()
- {
- return base_pro;
- }
- int use_base_pri()
- {
- return 1;//base_pri; //error
- }
- pub_derive():base() {}
- };
- class pro_derive : protected base {
- public:
- int use_base_pub()
- {
- return base_pub;
- }
- int use_base_pro()
- {
- return base_pro;
- }
- int use_base_pri()
- {
- return 1; //base_pri; //error
- }
- pro_derive():base() {}
- };
- class pri_derive : private base {
- public:
- int use_base_pub()
- {
- return base_pub;
- }
- int use_base_pro()
- {
- return base_pro;
- }
- int use_base_pri()
- {
- return 1 ;//base_pri; //error
- }
- pri_derive():base() {}
- };
- int main()
- {
- int a;
- base b;
- pub_derive pubd;
- pri_derive prid;
- pro_derive prod;
- //类自身的访问权限
- b.use_mypub(); //类 访问 自身的公有成员 ok
- b.use_myro(); //类 访问 自身的保护成员 ok
- b.use_mypri(); //类 访问 自身的私有成员 ok
- a = b.base_pub; //类对象 访问 自身的公有成员 ok
- //a = b.base_pro; //类对象 访问 自身的保护成员 error
- //a = b.base_pri; //类对象 访问 自身的私有成员 error
- //公有继承类的访问权限
- pubd.use_base_pub(); //公有继承类 访问 基类的公有成员 ok
- pubd.use_base_pro(); //公有继承类 访问 基类的保护成员 ok
- //pubd.use_base_pri(); //公用继承类 访问 基类的私有成员 error
- a = pubd.base_pub; //公有继承类对象 访问 基类的公有成员 ok
- //a = pubd.base_pro; //公有继承类对象 访问 基类的保护成员 error
- //a = pubd.base_pri; //公有继承类对象 访问 基类的私有成员 error
- //保护继承类的访问权限
- prod.use_base_pub(); //保护继承类 访问 基类的公有成员 ok
- prod.use_base_pro(); //保护继承类 访问 基类的保护成员 ok
- prod.use_base_pri(); //保护继承类 访问 基类的私有成员 error
- //a = prod.base_pub; //保护继承类对象 访问 基类的公有成员 error
- //a = prod.base_pro; //保护继承类对象 访问 基类的保护成员 error
- //a = prod.base_pri; //保护继承类对象 访问 基类的私有成员 error
- //私有继承类的访问权限
- prid.use_base_pub(); //私有继承类 访问 基类的公有成员 ok
- prid.use_base_pro(); //私有继承类 访问 基类的保护成员 ok
- prid.use_base_pri(); //私有继承类 访问 基类的私有成员 error
- //a = prid.base_pub; // 私有继承类对象 访问 基类的公有成员 error
- //a = prid.base_pro; // 私有继承类对象 访问 基类的保护成员 error
- //a = prid.base_pri; // 私有继承类对象 访问 基类的私有成员 error
- cout<<"OK"<<endl;
- return 1;
- }