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 继承方式；