zoukankan      html  css  js  c++  java
  • C++ 继承方式 继承同名成员处理 继承中的同名静态成员处理方式 多继承语法(认多个爹) 菱形继承

    #include <iostream>
    using namespace std;
    #include <string>
    
     //继承方式
    
    //公共继承
    class Basel 
    {
    public:
        int m_A;
    protected:
        int m_B;
    private:
        int m_C;
    };
    
    class Son1 : public Basel
    {
    public:
        void func()
        {
            m_A = 10; //父类中的公共权限成员 到子类中依然是公共权限
            m_B = 10; //父类中的保护权限成员 到子类中依然是保护权限
            //m_C = 10; //父类中的私有权限成员 子类访问不到
    
        }
    };
    
    void test01()
    {
        Son1 s1;
        s1.m_A = 100;
        //s1.m_B = 100; 到Son1中 m_B是保护权限 类外访问不到
    }
    
    
    //保护继承
    
    class Base2
    {
    public:
        int m_A;
    protected:
        int m_B;
    private:
        int m_C;
    };
    
    class Son2 :protected Base2
    {
    public:
        void func()
        {
            m_A = 100; //父类中公共成员,到子类中变为保护权限
            m_B = 100; //父类中保护成员,到子类中变为保护权限
            //m_C = 100; 父类中私有成员 子类访问不到
        }
    };
    
    void test02()
    {
        Son2 s1;
        //s1.m_A = 1000; 在Son2中m_A变为保护权限,因此类外访问不到
        //s1.m_B = 1000; 在Son2中 m_B变为保护权限 不可以访问
    }
    
    //私有继承
    class Base3
    {
    public:
        int m_A;
    protected:
        int m_B;
    private:
        int m_C;
    };
    
    class Son3 :private Base3
    {
    public:
        void func()
        {
            m_A = 100;//父类中公共成员 到子类中变为 私有成员
            m_B = 100;//父类中保护成员 到子类中变为 私有成员
            //m_C = 100; //父类中私有成员 到子类中访问不到
    
        }
    };
    
    void test03()
    {
        Son3 s1;
        s1.m_A = 100;//到Son3中变为私有成员 类外成员访问不到
    }
    
    
    
    int main()
    {
        test01();
        
        system("pause");
        return 0;
    
    }

    同名成员处理

    #include <iostream>
    using namespace std;
    #include <string>
    
    //继承中同名成员处理
    class Base
    {
    public:
        Base()
        {
            m_A = 100;
        }
        void func()
        {
            cout << "Base - func()调用 " << endl;
        }
    
    
        void func(int a)
        {
            cout << "Base - func(int a)调用 " << endl;
        }
    
        int m_A;
    };
    
    class Son :public Base
    {
    public:
        Son()
        {
            m_A = 200;
        }
    
        void func()
        {
            cout << "Son - func()调用 " << endl;
        }
    
        int m_A;
    };
    
    //同名属性处理方式
    void test01()
    {
        Son s;
        cout << "Son 下 m_A = " << s.m_A << endl;
        //如果通过子类对象 访问到父类中同名成员,需要加作用域
        cout << "Base 下 m_A = " << s.Base::m_A << endl;
    }
    
    //同名成员函数处理方式
    void test02()
    {
        Son s;
        s.func();//直接调用 调用是子类中的同名成员
    
    
        //如何调用到父类中同名成员函数?
        s.Base::func();
    
        //如果子类中出现和父类同名的成员函数,子类的同名成员会隐藏掉父类中所有同名成员函数
        //如果想访问到父类中被隐藏的同名成员函数,需加作用域
        s.Base::func(100);
    
    }
    
    int main()
    {
        //test01();
        test02();
        
        system("pause");
        return 0;
    
    }

     继承中的同名静态成员处理方式

    #include <iostream>
    using namespace std;
    #include <string>
    
    //继承中的同名静态成员处理方式
    
    class Base
    {
    public:
        static  int m_A;
    
        static void func()
        {
            cout << "Base - static void func()" << endl;
        }
    
        static void func(int a)
        {
            cout << "Base - static void func()" << endl;
        }
    };
    int Base::m_A = 100;
    
    class Son :public Base
    {
    public:
        static  int m_A;
    
        static void func()
        {
            cout << "Son - static void func()" << endl;
        }
    };
    int Son::m_A = 200;
    
    
    //同名静态成员属性
    void test01()
    {
        //1、通过对象访问
        cout << "通过对象访问" << endl;
        Son s;
        cout << "Son 下 m_A = " << s.m_A << endl;
        cout << "Base 下 m_A = " << s.Base::m_A << endl;
    
        //2、通过类名访问
        cout << "通过类名访问" << endl;
        cout << "Son 下 m_A = " << Son::m_A << endl;
        //第一个::代表通过类名方式访问  第二个::代表访问父类作用域下
        cout << "Base 下 m_A = " << Son::Base::m_A << endl;
    
    }
    
    //同名静态成员函数
    void test02()
    {
        //1、通过对象访问
        cout << "通过对象访问" << endl;
        Son s;
        s.func();
        s.Base::func();
    
    
        //2、通过类名访问
        cout << "通过类名访问" << endl;
        Son::func();
        Son::Base::func();
    
        //子类出现和父类同名静态成员函数,也会隐藏父类中所有同名成员函数
        //如果想访问父类中被隐藏同名成员,需要加作用域
        Son::Base::func(100);
    }
    
    
    int main()
    {
        //test01();
        test02();
        
        system("pause");
        return 0;
    
    }

     多继承语法(认多个爹)

    #include <iostream>
    using namespace std;
    #include <string>
    
    //多继承语法(认多个爹)
    
    
    //父类
    class Base1
    {
    public:
        Base1()
        {
            m_A = 100;
        }
        int m_A;
    };
    
    
    class Base2
    {
    public:
        Base2()
        {
            m_A = 200;
        }
        int m_A;
    };
    
    
    //子类 需要继承Base1和Base2
    //语法:class 子类: 继承方式 父类1, 继承方式 父类2 ...
    class Son :public Base1, public Base2
    {
    public:
        Son()
        {
            m_C = 300;
            m_D = 400;
        }
        int m_C;
        int m_D;
    };
    
    void test01()
    {
        Son s;
        cout << "sizeof Son = " << sizeof(s) << endl;
        //当父类中出现同名成员,需要加作用域区分
        cout << "Base1::m_A = " << s.Base1::m_A << endl;
        cout << "Base1::m_A = " << s.Base2::m_A << endl;
    }
    
    int main()
    {
        test01();
        //test02();
        
        system("pause");
        return 0;
    
    }

     菱形继承

    #include <iostream>
    using namespace std;
    #include <string>
    
    //菱形继承
    
    //动物类
    class Animal 
    {
    public:
        int m_Age;
    };
    
    //利用虚继承 解决菱形继承的问题
    //在继承之前加上关键字 virtual 变为虚继承
    // Animal 类成为 虚基类
    
    //羊类
    class Sheep :virtual public Animal {};
    
    //驼类
    class Tuo :virtual public Animal{};
    
    //羊驼类
    class SheepTuo : public Sheep, public Tuo {};
    
    void test01()
    {
        SheepTuo st;
        st.Sheep::m_Age = 18; 
        st.Tuo::m_Age = 28;
        //当菱形继承,两个父类拥有相同的数据,需要加以作用域区分
        cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
        cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
        cout << "st.m_Age = " << st.m_Age << endl;
    
        //这份数据我们知道 只有一份就可以,菱形继承导致数据有两份,资源浪费
    }
    
    int main()
    {
        test01();
        //test02();
        
        system("pause");
        return 0;
    
    }
  • 相关阅读:
    Sample XPS Documents Download
    触发器中的inserted表和deleted表
    Using freewheel.labs.autodesk.com to auto generate preview images of DWF files on your web site
    解除SQL对组件"Ad Hoc Distributed Queries"的"STATEMENT'OpenRowset OpenDatasource"的访问
    读写xps
    XPS文件,在Windows XP下的打开查看阅读和打印方法。
    Learning to Reference Inserted and Deleted Tables
    Get value from updated, inserted and deleted
    Reinstall Microsoft Helper Viewer
    如何查找文件的IFilter
  • 原文地址:https://www.cnblogs.com/keepma/p/15573135.html
Copyright © 2011-2022 走看看