【C++】继承 ⑤ ( public 公有继承 - 示例分析 | protected 保护继承 - 示例分析 | private 私有继承 - 示例分析 )

成员的访问属性 需要看根据下面的逻辑进行判定 :

• 调用位置 : 看是在哪调用的 , 在 类内部 , 派生类 ( 子类 ) , 还是在 类外部 ;
• 子类继承方式 :
  • 公有继承 : public
  • 保护继承 : protected
  • 私有继承 : private
• 父类中的访问级别 :
  • 公有成员 : public
  • 保护成员 : protected
  • 私有成员 : private

如 : 在类外部调用 , 子类 保护继承 父类的 公有成员 , 调用失败 , 因为 父类的 公有成员 被 子类 保护继承 后 , 变为子类的 保护成员 , 只能在 子类内部 或 孙子类中调用 , 不可在类外部调用 ;

特别注意 : 私有继承 , 基类 的 公有成员 和 保护成员 变为 派生类的 私有成员 , 这两种成员在 派生类内部是可以访问的 , 在 类外部 不可访问 ;

一、public 公有继承 - 示例分析

---

1、public 公有继承

public 公有继承 : 父类成员 在 子类 中 , 访问控制权限 不变 , 共有 和 保护成员 可以在子类访问 , 私有成员不可在子类中访问 ;

父类中的访问控制权限 如下变化 :

• 父类中的 public 成员 仍然是 public 成员 ;
• 父类中的 protected 成员 仍然是 protected 成员 ;
• 父类中的 private 成员 仍然是 private 成员 ;

2、代码示例 - public 公有继承

在下面的代码中 ,

基类 ( 父类 ) 中 , 定义了 公有变量 a , 保护变量 b , 私有变量 c ;

派生类 ( 子类 ) 中 , 分别访问了上述 3 个变量 ;

• 访问 公有变量 a : 公有继承 基类 公有变量 在子类中仍是 共有变量 , 该变量可被访问 , 父类 公有成员 可以在任意位置访问 , 这里的任意位置指的是 类内部 , 子类内部 , 类外部 ;

        // 可访问 : 父类 公有成员 可以在任意位置访问
        // 任意位置 : 类内部 , 子类内部 , 类外部
        a = 0;

• 访问 保护变量 b : 公有继承 基类 保护变量 在子类中仍是 保护变量 , 该变量在子类中是 保护成员 , 可以在 基类内部 和 子类内部访问 ;

        // 可访问 : 父类 保护成员 可以在 类内部 和 子类内部访问
        b = 0;

• 访问 私有变量 c : 公有继承 基类 私有变量 在子类中仍是 私有变量 , 该变量是 子类 中的 私有成员 , 只能在 基类中访问 ;

        // 报错 : “Parent::c”: 无法访问 private 成员(在“Parent”类中声明)
        // 私有成员只能在本类中访问 , 子类 和 类外部无法访问
        //c = 0;

类外部访问 派生类 ( 子类 ) 继承的 3 个变量 ;

• 访问 公有变量 a : 基类中的公有成员 , 公有继承 子类中仍是 公有成员 , 可以在类外部访问 ;

    // 基类中的公有成员
    // 公有继承 子类中仍是 公有成员 , 可以在类外部访问
    child.a;

• 访问 保护变量 b : 基类中的保护成员 , 公有继承 子类中仍是 保护成员 , 不可在类外部访问 ;

    // 不可访问 : 基类中的保护成员
    // 公有继承 子类中仍是 保护成员 , 不可在类外部访问
    //child.b;

• 访问 私有变量 c : 基类中的私有成员 , 公有继承 子类中仍是 私有成员 , 不可在类外部访问 ;

    // 不可访问 : 基类中的私有成员
    // 公有继承 子类中仍是 私有成员 , 不可在类外部访问
    //child.c;

代码示例 :

#include "iostream"
using namespace std;

class Parent {
public:
    int a;

protected:
    int b;

private:
    int c;
};

// 子类 公有继承 父类
class Child : public Parent {
public:
    void changeVar() {
        // 可访问 : 父类 公有成员 可以在任意位置访问
        // 任意位置 : 类内部 , 子类内部 , 类外部
        a = 0;

        // 可访问 : 父类 保护成员 可以在 类内部 和 子类内部访问
        b = 0;

        // 报错 : “Parent::c”: 无法访问 private 成员(在“Parent”类中声明)
        // 私有成员只能在本类中访问 , 子类 和 类外部无法访问
        //c = 0;
    }
};

int main() {

    Child child;
    child.changeVar();

    // 可访问 : 基类中的公有成员
    // 公有继承 子类中仍是 公有成员 , 可以在类外部访问
    child.a;

    // 不可访问 : 基类中的保护成员
    // 公有继承 子类中仍是 保护成员 , 不可在类外部访问
    //child.b;

    // 不可访问 : 基类中的私有成员
    // 公有继承 子类中仍是 私有成员 , 不可在类外部访问
    //child.c;
    

	// 控制台暂停 , 按任意键继续向后执行
	system("pause");

	return 0;
}

二、protected 保护继承 - 示例分析

---

1、protected 保护继承

protected 保护继承 : 父类成员 在 子类 中 , 访问控制权限 变为 protected , 基类的 公有成员 和 保护成员 可以在子类访问 , 私有成员不可在子类中访问 ;

父类中的访问控制权限 如下变化 :

• 父类中的 public 成员 变为 子类中的 protected 成员 ;
• 父类中的 protected 成员 仍然是 protected 成员 ;
• 父类中的 private 成员 仍然是 private 成员 ;

2、代码示例 - protected 保护继承

在下面的代码中 ,

基类 ( 父类 ) 中 , 定义了 公有变量 a , 保护变量 b , 私有变量 c ;

派生类 ( 子类 ) 中 , 分别访问了上述 3 个变量 ;

• 访问 公有变量 a : 保护继承 基类 公有变量 在子类中 变为 保护变量 , 该变量可 在 派生类中 被访问 ;

        // 可访问 : 父类 公有成员 变为 保护成员
        // 可在 类内部 , 子类内部 访问该成员
        a = 0;

• 访问 保护变量 b : 保护继承 基类 保护变量 在子类中仍是 保护变量 , 该变量在子类中是 保护成员 , 可以在 基类内部 和 子类内部访问 ;

        // 可访问 : 父类 保护成员 可以在 类内部 和 子类内部访问
        b = 0;

• 访问 私有变量 c : 保护继承 基类 私有变量 在子类中仍是 私有变量 , 该变量是 子类 中的 私有成员 , 只能在 基类中访问 ,

        // 报错 : “Parent::c”: 无法访问 private 成员(在“Parent”类中声明)
        // 私有成员只能在本类中访问 , 子类 和 类外部无法访问
        //c = 0;

类外部访问 派生类 ( 子类 ) 继承的 3 个变量 ;

• 访问 公有变量 a : 基类中的公有成员 , 保护继承 子类中 变成 保护成员 , 可以在类外部访问 ;

    // 不可访问 : 基类中的公有成员
    // 保护继承 子类中仍是 公有成员 , 可以在类外部访问
    //child.a;

• 访问 保护变量 b : 基类中的保护成员 , 保护继承 子类中仍是 保护成员 , 不可在类外部访问 ;

    // 不可访问 : 基类中的保护成员
    // 保护继承 子类中仍是 保护成员 , 不可在类外部访问
    //child.b;

• 访问 私有变量 c : 基类中的私有成员 , 保护继承 子类中仍是 私有成员 , 不可在类外部访问 ;

    // 不可访问 : 基类中的私有成员
    // 保护继承 子类中仍是 私有成员 , 不可在类外部访问
    //child.c;

代码示例 :

#include "iostream"
using namespace std;

class Parent {
public:
    int a;

protected:
    int b;

private:
    int c;
};

// 子类 保护继承 父类
class Child : protected Parent {
public:
    void changeVar() {
        // 可访问 : 父类 公有成员 变为 保护成员
        // 可在 类内部 , 子类内部 访问该成员
        a = 0;

        // 可访问 : 父类 保护成员 可以在 类内部 和 子类内部访问
        b = 0;

        // 报错 : “Parent::c”: 无法访问 private 成员(在“Parent”类中声明)
        // 私有成员只能在本类中访问 , 子类 和 类外部无法访问
        //c = 0;
    }
};

int main() {

    Child child;
    child.changeVar();

    // 不可访问 : 基类中的公有成员
    // 保护继承 子类中仍是 公有成员 , 可以在类外部访问
    //child.a;

    // 不可访问 : 基类中的保护成员
    // 保护继承 子类中仍是 保护成员 , 不可在类外部访问
    //child.b;

    // 不可访问 : 基类中的私有成员
    // 保护继承 子类中仍是 私有成员 , 不可在类外部访问
    //child.c;
    

	// 控制台暂停 , 按任意键继续向后执行
	system("pause");

	return 0;
}

三、private 私有继承 - 示例分析

---

1、private 私有继承

private 私有继承 : 父类成员 在 子类 中 , 所有成员的访问控制权限 变为 private , 基类的 所有成员 都不可在子类中访问 ;

父类中的访问控制权限 如下变化 :

• 父类中的 public 成员 变为 子类中的 private 成员 ;
• 父类中的 protected 成员 变为 子类中的 private 成员 ;
• 父类中的 private 成员 仍然是 private 成员 ;

2、代码示例 - private 私有继承

在下面的代码中 ,

基类 ( 父类 ) 中 , 定义了 公有变量 a , 保护变量 b , 私有变量 c ;

派生类 ( 子类 ) 中 , 分别访问了上述 3 个变量 ;

• 访问 公有变量 a : 私有继承 基类 公有变量 在子类中 变为 子类的私有变量 , 父类中是公有成员 , 该变量可 在 派生类中 被访问 ;

        // 可访问 : 父类 公有成员 变为 子类 私有成员
        // 可在 子类内部 访问该成员
        a = 0;

• 访问 保护变量 b : 私有继承 基类 保护变量 在子类中仍是 保护变量 , 该变量在子类中是 私有成员 , 父类中是保护成员 , 可以在 基类内部 和 子类内部访问 ;

        // 可访问 : 父类 保护成员 变为 子类 私有成员
        // 子类私有成员 可以在 子类内部访问
        b = 0;

• 访问 私有变量 c : 私有继承 基类 私有变量 在子类中仍是 私有变量 , 该变量是 子类 中的 私有成员 , 只能在 基类中访问 ,

        // 报错 : “Parent::c”: 无法访问 private 成员(在“Parent”类中声明)
        // 私有成员只能在本类中访问 , 子类 和 类外部无法访问
        //c = 0;

类外部访问 派生类 ( 子类 ) 继承的 3 个变量 ;

• 访问 公有变量 a : 基类中的公有成员 , 私有继承 子类中 变成 子类的私有成员 , 不可以在类外部访问 ;

    // 不可访问 : 基类中的 公有成员 变为 派生类 私有成员
    // 私有继承 子类中 的私有成员 , 不可在类外部访问
    //child.a;

• 访问 保护变量 b : 基类中的保护成员 , 私有继承 子类中变为子类的 保护成员 , 不可在类外部访问 ;

    // 不可访问 : 基类中的 保护成员 变为 派生类 私有成员
    // 私有继承 子类中 的私有成员 , 不可在类外部访问
    //child.b;

• 访问 私有变量 c : 基类中的私有成员 , 私有继承 子类中仍是 父类的私有成员 , 不可在类外部访问 ;

    // 不可访问 : 基类中的私有成员
    // 私有继承 子类中仍是 私有成员 , 不可在类外部访问
    //child.c;

代码示例 :

#include "iostream"
using namespace std;

class Parent {
public:
    int a;

protected:
    int b;

private:
    int c;
};

// 子类 私有继承 父类
class Child : private Parent {
public:
    void changeVar() {
        // 可访问 : 父类 公有成员 变为 子类 私有成员
        // 可在 子类内部 访问该成员
        a = 0;

        // 可访问 : 父类 保护成员 变为 子类 私有成员
        // 子类私有成员 可以在 子类内部访问
        b = 0;

        // 报错 : “Parent::c”: 无法访问 private 成员(在“Parent”类中声明)
        // 私有成员只能在本类中访问 , 子类 和 类外部无法访问
        //c = 0;
    }
};

int main() {

    Child child;
    child.changeVar();

    // 不可访问 : 基类中的 公有成员 变为 派生类 私有成员
    // 私有继承 子类中 的私有成员 , 不可在类外部访问
    //child.a;

    // 不可访问 : 基类中的 保护成员 变为 派生类 私有成员
    // 私有继承 子类中 的私有成员 , 不可在类外部访问
    //child.b;

    // 不可访问 : 基类中的私有成员
    // 私有继承 子类中仍是 私有成员 , 不可在类外部访问
    //child.c;
    

	// 控制台暂停 , 按任意键继续向后执行
	system("pause");

	return 0;
}