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

文章目录

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

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

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

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

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

1、private 私有继承
2、代码示例 - 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;
}