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

小鱼儿 2024-02-21 08:53 61阅读 0赞

#### 文章目录 ####

*  一、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;
    }