C++中的三種繼承方式

1，被忽略的細節：

    1，冒號（ ：）表示繼承關系，Parent 表示被繼承的類，public 的意義是什么？

class Parent
{
            
};
        
class Child : public Parent
{
        
};

      

2，有趣的問題：

    1，是否可以將繼承語句中的 public 換成 protected 或者 private？如果可以，與 public 繼承有什么區別？

   

3，有趣的嘗試編程實驗：

#include <iostream>
#include <string>

using namespace std;

class Parent
{
};

class Child_A : public Parent
{
};

class Child_B : protected Parent
{
};

class Child_C : private Parent
{
};

int main()
{   
    return 0;
}

    1，protected 和 private 地位對等，推理的角度可以過，實際的編譯結果也是同樣的結論；

    2，本文主要分析這三種繼承方式有何不同；

   

4，不同的繼承方式（這是父類成員在子類中被外界訪問的級別）：

    1，C++ 中支持三種不同的繼承方式；

       　　1，public 繼承：

           　　1，父類成員在子類中保持原有訪問級別；

       　　2，private 繼承：

           　　1，父類成員在子類中變為私有成員；

      　　 3，protected 繼承：

           　　1，父類中的公有成員變為保護成員，其它成員保持不變；        

    2，繼承成員的屬性：

 

       　　1，Max{繼承方式，父類成員訪問屬性}；

       　　2，C++ 中的默認繼承方式為 private；

    3，繼承與訪問級別深度實踐編程實驗：

#include <iostream>
#include <string>

using namespace std;

class Parent
{
protected:
    int m_a;
protected:
    int m_b;
public:
    int m_c;
    
    void set(int a, int b, int c)
    {
        m_a = a;
        m_b = b;
        m_c = c;
    }
};

class Child_A : public Parent
{
public:
    void print()
    {
        cout << "m_a" << m_a << endl;
        cout << "m_b" << m_b << endl;
        cout << "m_c" << m_c << endl;
    }
};

class Child_B : protected Parent
{
public:
    void print()
    {
        cout << "m_a" << m_a << endl;
        cout << "m_b" << m_b << endl;
        cout << "m_c" << m_c << endl;
    }
};

class Child_C : private Parent
{
public:
    void print()
    {
        cout << "m_a" << m_a << endl;
        cout << "m_b" << m_b << endl;
        cout << "m_c" << m_c << endl;
    }
};

int main()
{   
    Child_A a;
    Child_B b;
    Child_C c;
    
    a.m_c = 100;
    // b.m_c = 100;    // Child_B 保護繼承自 Parent， 所以所有 public 成員全部變成了 protected 成員， 因此外界無法訪問；
    // c.m_c = 100;    // Child_C 私有繼承自 Parent， 所以所有的成員全部變成了 private 成員， 因此外界無法訪問；
    
    a.set(1, 1, 1);
    // b.set(2, 2, 2);  // 保護繼承；
    // c.set(3, 3, 3);  // 私有繼承；
    
    a.print();  // 繼承方式只影響繼承自父類成員的訪問方式，外界訪問子類方式無影響；
    b.print();  // 繼承方式只影響繼承自父類成員的訪問方式，外界訪問子類方式無影響；
    c.print();  // 繼承方式只影響繼承自父類成員的訪問方式，外界訪問子類方式無影響；
    
    return 0;
}

       　　1，父類中的訪問級別影響着子類的訪問，但是繼承級別不影響子類的訪問、影響其它外部類訪問父類中的成員；

      

5，遺憾的事實：

    1，一般而言，大型的 C++ 工程項目中只使用 public 繼承；

       1，這已經足夠了；

       2，保護繼承和私有繼承根本就沒什么用；

    2，C++ 的派生語言只支持一種繼承方式（public 繼承）；

       1，Java、C# 等語言只有一種繼承方式即 public 繼承方式；

    3，protected 和 private 繼承帶來的復雜性遠大於實用性；

       1，僅在學術研究領域研究；

   

6，C++ 派生語言初探編程實驗：

    1，D 語言（在 Linux 中用 gdc 編譯，生成 *.out 文件）：

module D_Demo;  // 將下面的所有代碼定義為模塊，模塊名字為 
D_Demo；

import std.stdio;  // import 同 include
import std.string;  // import 同 include

class Obj  // 這里定義了一個 Obj 類
{
protected:
    string mName;
    string mInfo;
    
public:
    this()  // 這是 D 語言中的構造函數，D 語言中的構造函數統一的用 this 這個關鍵字表示，由 C++ 進化而來；
    {
        mName = "Object";
        mInfo = "";
    }
    
    string name()  // 定義兩個成員函數；
    {
        return mName;
    }
    
    string info()
    {
        return mInfo;
    }
}

class Point : Obj  // 定義了一個類 Point，其繼承自 Obj，D 語言中的繼承方式默認的是 public 繼承；
{
private:
    int mX;
    int mY;
    
public:
    this(int x, int y)
    {
        mX = x;
        mY = y;
        mName = "Point";
        mInfo = format("P(%d, %d)", mX, mY);  // 和 C 語言中的語法規則一樣；
    }
    
    int x()
    {
        return mX;
    }
    
    int y()
    {
        return mY;
    }
}

void main(string[] args)  // 程序運行的入口；
{
    writefln("D Demo");        // D Demo；打印語句之后空一行，同 printf；
    
    Point p = new Point(1, 2);  // 動態生成 Point 對象；
    
    writefln(p.name());           // Point，公有繼承；
    writefln(p.info());           // P(1, 2)，公有繼承；
}

       1，沒學過 D 語言，但是要讀懂 D 語言的代碼是比較容易的；

       2，如果因工作需要要學習 D 語言程序設計，將是輕而易舉的事情；

    2，C# 語言（Linux 中用 gmcs 編譯，生成 *.exe 文件）：

class Obj  // 定義一個類 Obj；
{
    protected string mName;  // 訪問屬性 protected；
    protected string mInfo;
    
    public Obj()  // 無返回值，函數名同類名，即構造函數，訪問屬性為 public；
    {
        mName = "Object";
        mInfo = "";
    }
    
    public string name()
    {
        return mName;
    }
    
    public string info()
    {
        return mInfo;
    }
}

class Point : Obj  // 定義一個類 Point，繼承自 Obj，只有一種 public 繼承方式；
{

    private int mX;
    private int mY;

    public Point(int x, int y)  // 構造函數；
    { 
        mX = x;
        mY = y;
        mName = "Point";
        mInfo = "P(" + mX + ", " + mY + ")";  // 通過 + 操作符來連接字符串和整型變量，最終得到一個字符串；C++ 中可以通過重載全局的 + 操作符就能夠連接一個字符串和一個整型變量最終得到一個字符串，別的語言中的特性，不明白的話，考慮下在 C++ 中如何實現；                                          
    }
    
    public int x()
    {
        return mX;
    }
    
    public int y()
    {
        return mY;
    }
}

class Program
{
    public static void Main(string[] args)  // 程序入口
    {
        System.Console.WriteLine("C# Demo");    // C# Demo
        
        Point p = new Point(1, 2);
        
        System.Console.WriteLine(p.name());     // Point
        System.Console.WriteLine(p.info());     // P(1, 2)
        
    }
}

    3，Java 程序：

class Obj
{
    protected String mName;
    protected String mInfo;
    
    public Obj()
    {
        mName = "Object";
        mInfo = "";
    }
    
    public String name()
    {
        return mName;
    }
    
    public String info()
    {
        return mInfo;
    }
}

class Point extends Obj  // extends 表示公有繼承，更加直觀；
{

    private int mX;
    private int mY;

    public Point(int x, int y)
    { 
        mX = x;
        mY = y;
        mName = "Point";
        mInfo = "P(" + mX + ", " + mY + ")";
    }
    
    public int x()
    {
        return mX;
    }
    
    public int y()
    {
        return mY;
    }
}

class Program {
    public static void main(String[] args){  // 程序運行如口
        System.out.println("Java Demo");    // Java Demo
        
        Point p = new Point(1, 2);
        
        System.out.println(p.name());       // Point
        System.out.println(p.info());       // P(1, 2)
    }
}

       1，現在已經有能力讀懂 D、C#、Java 語言程序了；

           1，C#、Java 可以從事網絡開發、游戲開發；

           2，D 語言可以從事系統開發；

       2，工程里面，僅僅使用 public 繼承就夠了；

      

7，小結：

    1，C++ 中支持 3 種不同的繼承方式；

    2，繼承方式直接影響父類成員在子類中的訪問屬性；

    3，一般而言，工程中只使用 public 的繼承方式；

    4，C++ 的派生語言中只支持 public 繼承方式；