c++继承

继承分为公有，私有，保护。具体定义是什么自己去查，网上多了（那定义真是云里雾里，就他自己能看懂）。这里主要是通俗易懂的程序。

代码（好多编译器用添加头文件的方式写继承都会报错，解决方法就是全写在int main()里面）：

第一部分：公有，私有，保护：

1.数值的继承：

#include <iostream>
using namespace std;

class A{
public:
    A(){                                //类里面赋值用构造函数，不要用int a=0,int b=1,int c=2会报出莫名其妙的错误..
        a = 0;
        b = 1;
        c = 2;
    }
    int a;
protected:
    int b;
private:
    int c;
};

class B : public A
{
    public:
        void show1()
        {                          
            cout<<a<<b<<endl;       //这里只能输出a,b不能输出c.
        }
};



class C : protected A
{
    public:
        void show1()
        {
            cout<<a<<b<<endl;       //这里只能输出a,b不能输出c
        }
};



class D : private A
{
    public:
        void show1()
        {
            cout<<a<<b<<endl;       //这里只能输出a,b不能输出c
        }
};


int main()
{
    B x;
    x.show1();
    C y;
    y.show1();
    D z;
    z.show1();

    return 0;
}

2.函数的继承：

#include <iostream>
using namespace std;

class A{
public:
    A(){                                
        a = 0;
        b = 1;
        c = 2;
    }
    int a;
    int sum1()
    {
        int x=a+6;
        return x;
    }
protected:
    int b;
    int sum2()
    {
        int x=b+6;
        return x;
    }
private:
    int c;
    int sum3()
    {
        int x=c+6;
        return x;
    }
};

class B : public A                      //只能够将公有和保护的函数调用。
{
    public:
        void show1()
        {
            int x=0;
            x+=sum1();
            cout<<x<<endl;
        }
         void show2()
        {
            int x=0;
            x+=sum2();
            cout<<x<<endl;
        }
        /*void show3()
        {
            int x=0;
            x+=sum3();
            cout<<x<<endl;
        }*/
};



class C : protected A                   //public和protect的函数都可以调用。
{
    public:
        void show1()
        {
            int x=0;
            x+=sum1();
            cout<<x<<endl;
        }
         void show2()
        {
            int x=0;
            x+=sum2();
            cout<<x<<endl;
        }
        /*void show3()
        {
            int x=0;
            x+=sum3();
            cout<<x<<endl;
        }*/
};



class D : private A                         //一个函数都不能调用。
{
        /*void show1()
        {
            int x=0;
            x+=sum1();
            cout<<x<<endl;
        }*/
         /*void show2()
        {
            int x=0;
            x+=sum2();
            cout<<x<<endl;
        }*/
        /*void show3()
        {
            int x=0;
            x+=sum3();
            cout<<x<<endl;
        }*/
};


int main()
{
    B x;
    x.show1();
    x.show2();

    C y;
    y.show1();
    y.show2();
    //y.show3();

    D z;
    //z.show1();
    //z.show2();
    //z.show3();
    return 0;
}

第二部分：

main（）的深入调用：

///

#include <iostream>
using namespace std;

class A{
public:
    void show7()
    {
        cout<<666<<endl;
    }
protected:
    void show8()
    {
        cout<<666<<endl;
    }
private:
    void show9()
    {
        cout<<666<<endl;
    }
};

class B : public A
{
    public:

};


int main()
{
    B x;
    x.show7();          //这种方式也就是对象的方法，main里只能调用public，一定要注意。
    
    return 0;
}

//

#include <iostream>
using namespace std;


class A
{
public:
    A()
    {
        a=1;
    }
    int a;
    void show()
    {
        cout<<a<<endl;
    }
};


class B : public A
{
public:
    B()
    {
        b=1;
    }
    int b;
    void show1()
    {
        cout<<b<<endl;
    }
};


int main()
{
    B x;
    cout<<x.a<<endl;
    cout<<x.b<<endl;


    x.show();           //继承的一重调用。
    x.show1();
    return 0;
}

//

#include <iostream>
using namespace std;


class A
{
public:
    A()
    {
        a=1;
    }
    void show1()
    {
        cout<<"A"<<endl;
    }
    int a;
};


class B : public A
{
public:
    B()
    {
        b=2;
    }
    void show2()
    {
        cout<<"B"<<endl;
    }
    int b;
};


class C : public A
{
public:
    C()
    {
        c=3;
    }
    void show3()
    {
        cout<<"C"<<endl;
    }
    int c;
};


class D : public B, public C
{
public:
    D()
    {
        d=4;
    }
    void show4()
    {
        cout<<"D"<<endl;
    }
    int d;
};


int main()
{
    D x;
    cout<<x.B::a<<endl;             //用一点小技巧就可以无限深入的调用。
    cout<<x.b<<endl;
    cout<<x.c<<endl;
    cout<<x.d<<endl;


    x.B::show1();
    x.show2();
    x.show3();
    x.show4();


    return 0;
}

第三部分：虚基类（像上面第二部分那种要是层数超过10000层，那"::"得写多少，为了简化，出现了虚基类）。

#include <iostream>
using namespace std;

class A
{
public:
    A()
    {
        a=1;
    }
    void show1()
    {
        cout<<"A"<<endl;
    }
    int a;
};

class B : virtual public A				//public前加了virtual要注意。
{
public:
    B()
    {
        b=2;
    }
    void show2()
    {
        cout<<"B"<<endl;
    }
    int b;
};

class C : virtual public A
{
public:
    C()
    {
        c=3;
    }
    void show3()
    {
        cout<<"C"<<endl;
    }
    int c;
};

class D : virtual public B, virtual public C
{
public:
    D()
    {
        d=4;
    }
    void show4()
    {
        cout<<"D"<<endl;
    }
    int d;
};

class E : virtual public D
{
public:
    E()
    {
        e=4;
    }
    void show5()
    {
        cout<<"E"<<endl;
    }
    int e;
};

int main()
{
    E x;
    cout<<x.a<<endl;             
    cout<<x.b<<endl;
    cout<<x.c<<endl;
    cout<<x.d<<endl;
    cout<<x.e<<endl;

    x.show1();
    x.show2();
    x.show3();
    x.show4();
    x.show5();

    return 0;
}

第四部分：构造函数，不会，用到再说。

第五部分：继承的重用（设class B ：public A，则在B中想要改掉A的某个函数 ）

#include <iostream>
using namespace std;

class A
{
public:
    virtual void show()                 //注意函数前面加virtual。
    {
        cout<<"AAA"<<endl;
    }
};

class B : virtual A                     //别用private就行，为什么，private总是会出一些奇怪的error。
{
public:
    virtual void show()                 //照着A抄下来，函数里面就是重写的内容。
    {
        cout<<"BBB"<<endl;
    }
};

int main()
{
    B x;
    x.show();
    return 0;
}

哪里不对请指正。