C++ | 继承关系与成员属性

心已赠人 2023-01-07 10:18 153阅读 0赞

#### 1.继承限定符 ####

公有继承限定符：子类继承时，**按照原本的成员属性继承**。  
保护继承限定符：子类继承时，**继承后的属性不高于保护属性**。（public => protected）  
私有继承限定符：子类继承时，**继承后的属性不高于私有属性**。（public => private 、protected => private）

#### 2.访问限定符 ####

p u b l i c ： \{ 属 性 ： 类 外 可 访 问 ， 类 内 可 访 问 。 特 点 ： 子 类 继 承 时 可 以 继 承 全 部 特 性 （ 受 成 员 限 定 符 限 制 ） 。 public：\\begin\{cases\} 属性：类外\{\\color\{red\}可\}访问，类内\{\\color\{red\}可\}访问。\\\\ 特点：子类继承时可以继承全部特性（受成员限定符限制）。 \\end\{cases\} public：\{ 属性：类外可访问，类内可访问。特点：子类继承时可以继承全部特性（受成员限定符限制）。

关于public：

*  在本类中，可在类中访问，也可在类外访问。
 *  在派生类中，与基类相同。派生类中可访问，派生类外也可访问。

p r i v a t e ： \{ 属 性 ： 类 外 不 访 问 ， 类 内 可 访 问 。 特 点 ： 该 属 性 成 员 不 可 被 子 类 继 承 。 （ 子 类 继 承 ， 但 不 可 见 ） private：\\begin\{cases\} 属性：类外\{\\color\{red\}不\}访问，类内\{\\color\{red\}可\}访问。\\\\ 特点：该属性成员不可被子类继承。（子类继承，但不可见） \\end\{cases\} private：\{ 属性：类外不访问，类内可访问。特点：该属性成员不可被子类继承。（子类继承，但不可见）

关于private：

*  在本类中，可在类中访问，不可在类外访问。
 *  在派生类中，**不可访问**。

需要注意的是，关于private属性的成员变量，表示不允许子类使用父类中该种属性的变量。因此，对于任意一种继承方式（公有继承/保护继承/私有继承）来说，子类中对其都是不可见的。即**子类对父类的私有成员不可见**。

p r o t e c t e d ： \{ 属 性 ： 类 外 不 访 问 ， 类 内 可 访 问 。 特 点 ： 1. 本 类 中 等 同 于 p r i v a t e 。 2. 子 类 可 访 问 父 类 的 p r o t e c t e d 成 员 。 protected： \\begin\{cases\} 属性：类外\{\\color\{red\}不\}访问，类内\{\\color\{red\}可\}访问。\\\\ 特点：1.本类中等同于private。\\\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ 2.子类可访问父类的protected成员。 \\end\{cases\} protected：⎩⎪⎨⎪⎧属性：类外不访问，类内可访问。特点：1.本类中等同于private。2.子类可访问父类的protected成员。  
关于protected：

*  在本类中，protected 的特点与 private 相似，只能类中访问，不可在类外访问。
 *  在派生类中，protected 的特点结合了 public与private ，派生类中可访问，派生类外不可访问。

#### 3.继承关系 ####

由于有 继承关系限定符 和 成员访问限定符 两种方式叠加作用于子类的继承成员，因此我们可通过**取两者中权限缩小的方式**判断继承后成员的访问属性。如public+protected => protected 、public+private => private 。

<table> 
 <thead> 
  <tr> 
   <th>继承方式</th> 
   <th>成员属性（继承关系+父类中成员限定）</th> 
   <th>在子类中的属性</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public</td> 
   <td>public+<strong>public</strong> =&gt; public</td> 
   <td>可访问，等同于子类<code>public</code>(类外也可直接访问)</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>public+<strong>protected</strong> =&gt; protected</td> 
   <td>可访问，等同于子类<code>protected</code></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>public+<strong>private</strong> =&gt; private</td> 
   <td>子类中<code>不可见</code>成员</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>protected+<strong>public</strong> =&gt; protected</td> 
   <td>可访问，等同于子类<code>protected</code></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>protected+<strong>protected</strong> =&gt; protected</td> 
   <td>可访问，等同于子类<code>protected</code></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>protected+<strong>private</strong> =&gt; private</td> 
   <td>子类中<code>不可见</code>成员</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>private</td> 
   <td>private+<strong>public</strong> =&gt; private</td> 
   <td>可访问，等同于子类<code>private</code></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>private+<strong>protected</strong> =&gt; private</td> 
   <td>可访问，等同于子类<code>private</code></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>private+<strong>private</strong> =&gt; private</td> 
   <td>子类中<code>不可见</code>成员</td> 
  </tr> 
 </tbody> 
</table>

但无论哪种继承方式，上面两点都没有改变：

1.private成员只能被成员函数和 友元 访问，不能被派生类访问；

2.protected成员可以被派生类访问。（当然public成员也是可以的）

测试用例：

class Base {
        
    public :int ba = 0;
    protected:int bb = 0;
    private:int pc = 0;
    };
    
    class A :public Base {
        
    public:
    	void show()
    	{
        
    		ba = 11;	// public
    		bb = 12;	// protected
    		//bc;	// 不可见
    
    		cout << "public:" << ba << " " << bb << endl;
    	}
    };
    class B :protected Base {
        
    public:
    	void show()
    	{
        
    		ba = 21;//protected
    		bb = 22;//protected
    		//bc;	// 不可见
    
    		cout << "protected:" << ba << " " << bb << endl;
    	}
    };
    class C :private Base {
        
    public:
    	void show()
    	{
        
    		ba = 31;//private
    		bb = 32;//private
    		//bc;	// 不可见
    
    		cout <<"private:"<< ba << " " << bb << endl;
    	}
    };
    
    int main()
    {
        
    	A a;
    	B b;
    	C c;
    	a.show();
    	b.show();
    	c.show();
    
    	a.ba;	// public+public
    	
    	return 0;
    }

此外通过以上的示例，可知拥有继承关系时，子对象总是可以通过**子函数**访问父对象的**公有成员**和**保护成员**。  
如上例中的 a.show();b.show();c.show()中都可以访问到基类Base类中的public :int ba；protected:int bb；