C++旅程第七站-----类的继承

这是她

Wanting to be someone else is a waste of the person you are.        --Kurt Cobain
                                                                                                                 类的继承
           继承的好处：减少重复代码
           语法：class 子类 ： 继承方式  父类
                    子类 -> 派生类        父类 -> 基类
           派生类中的成员：
           1、从基类继承过来;(共性)            2、自己增加的成员;(特性)

          继承方式：公共继承  私有继承  保护继承

#include<iostream>

using namespace std;

class Base1
{
        public:
                int m_A;
                
                void Headline1()
                {
                        cout << "文件的标题！！！！" << endl;
                }
                
                void Time1()
                {
                        cout << "文件创建的时间！！！！" << endl;; 
                }
                
                void Author1()
                {
                        cout << "文件的作者！！！！" << endl; 
                }
                
        private:
                int m_B;
                
        protected:
                int m_C;
};
//继承的方式有三种：公共继承    保护继承    私有继承 
//class 子类 : 继承方式 父类           

//公共继承   public 
class File1 : public Base1
{
        public:
                void Content1()
                {
                        cout << "文件的内容！！！！！！" << endl; 
                }
};

//公共继承  public 
class File2 : public Base1
{
        public:
                void test1()
                {
                        int m_A = 10;//父类中的公共权限成员----子类->公共权限 
                        int m_B = 10;//父类中的私有权限成员----子类->访问不到 
                        int m_C = 10;//父类中的保护权限成员----子类->保护权限 
                }
}

//私有继承   private 
class File3 : private Base1
{
        public:
                void test2()
                {
                        int m_A = 11;//父类中的公共权限成员----子类->私有权限 
                        int m_B = 11;//父类中的私有权限成员----子类->访问不到 
                        int m_C = 11;//父类中的保护权限成员----子类->私有权限 
                }
}

//保护继承   protected 
class File4 : protected Base1
{
        public:
                void test3()
                {
                        int m_A = 12;//父类中的公共权限成员----子类->保护权限 
                        int m_B = 12;//父类中的私有权限成员----子类->访问不到 
                        int m_C = 12;//父类中的保护权限成员---- 子类->保护权限 
                }
}

int main()
{
        File1 f1;
        f1.Content1();
        f1.Headline1();
        f1.Time1();
        f1.Author1();
        
        File2 f2;
        f2.m_A = 100;//公共权限---可以访问到 
        f2.m_C = 100;//保护权限---类外访问不到 
        
        File3 f3;
        f3.m_A = 110;//私有权限---访问不到
        
        File4 f4;
        f4.m_A = 120;//保护权限---类外访问不到 
        
        return 0;
}

        继承中的对象模型

#include<iostream>

using namespace std;

class Base2
{
        public:
                int m_A;
                
                Base2()
                {
                        cout << "Base2 的构造函数！！！！" << endl; 
                }
                
                ~Base2()
                {
                        cout << "Base2 的析构函数！！！！" << endl; 
                }        
        
        private:
                int m_B;
        protected:
                int m_C;
};

class Box : public Base2
{
        public:
                int m_D;
                
                Box()
                {
                        cout << "Box 的构造函数！！！！" << endl; 
                }
                
                ~Box()
                {
                        cout << "Box 的析构函数！！！！" << endl; 
                }
};

int main()
{
        //16
        //父类中所有非静态成员属性都会被子类继承下去
        //父类中私有成员属性--是被编译器给隐藏了，因此访问不到，但确实被继承下去了 
        cout << "size of Box : " << sizeof(Box) << endl;
        
        //继承中的构造和析构顺序如下：
        //先构造父类，在构造子类，析构的顺序与构造的顺序相反 
        Base2 b1;
        Box b2;
        
        return 0; 
} 

        同名成员
          访问子类同名成员-----直接访问                     访问父类同名成员-----需要加作用域
          静态同名成员访问方式：    通过对象    通过类名

#include<iostream>

using namespace std;

class Base3
{
        public:
                int m_A;
                static int m_B;
                
                Base3()
                {
                        m_A = 10;
                }
                
                void magic()
                {
                        cout << "Base3 中的magic()!!!!" << endl; 
                }
                
                void magic(int a)
                {
                        cout << "Base3 中的magic(int a)!!!!" << endl;
                }
                
                static void cute()
                {
                        cout << "Base3 中的静态cute()!!!!" << endl; 
                }
};

int Base3::m_B = 20;

class Contemptible : public Base3
{
        public:
                int m_A;
                static int m_B;
                
                Contemptible()
                {
                        m_A = 100;
                }
                
                void magic()
                {
                        cout << "Contemptible 中的magic()!!!!" << endl;
                }        
                
                static void cute()
                {
                        cout << "Contemptible 中的静态cute()!!!!" << endl; 
                }
};

int Contemptible::m_B = 200;

//同名成员属性 
void test1()
{
        //如果成员属性有重名 
        Contemptible p1; 
        cout <<"子类中的成员属性 : " << p1.m_A << endl;//直接调用 
        cout <<"父类中的成员属性 ： " <<  p1.Base3::m_A << endl;
        //如果通过子类对象访问到父类中同名成员，需要加作用域  ：： 
}

//同名成员函数 
void test2()
{
        //如果成员函数有重名 
        Contemptible p2;
        p2.magic();//直接调用，调用的是子类中的同名成员 
        p2.Base3::magic();// 如果通过子类对象访问到父类中同名函数，需要加作用域  ：：
        //如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
        //如果想访问到父类中被隐藏的同名成员函数，需要加作用域：： 
        p2.Base3::magic(1); 
}

void test3()
{
        //1、通过对象访问
        cout << "通过对象来访问！！！" << endl; 
        Contemptible p3;
        cout <<"子类中的静态成员属性 : " << p3.m_B << endl;
        cout <<"父类中的静态成员属性 ： " <<  p3.Base3::m_B << endl;
        
        //2、通过类名来访问
        cout << "通过类名来访问！！！！" << endl;
        cout <<"子类中的成员属性 : " << Contemptible::m_B << endl;
        //第一个：：代表通过类名的方式访问  第二个：：代表访问父类作用域下 
        cout <<"父类中的成员属性 ： " <<  Contemptible::Base3::m_B << endl; 
}

void test4()
{
        //如果子类中出现和父类同名的静态成员函数，子类的静态同名成员会隐藏掉父类中所有静态同名成员函数
        //如果想访问到父类中被隐藏的静态同名成员函数，需要加作用域：： 
        
        //通过对象访问 
        Contemptible p4;
        p4.cute();
        p4.Base3::cute();
        
        //通过类名访问
        Contemptible::cute();
        Contemptible::Base3::cute(); 
}

int main()
{
        test1();
        
        test2();
        
        test3();
        
        test4();
        
        return 0;
}

       多继承

#include<iostream>

using namespace std;

class Library1
{
        public:
                int m_A;
                
                Library1()
                {
                        m_A = 10;
                }
};

class Library2
{
        public:
                int m_B;
                int m_A;
                
                Library2()
                {
                        m_B = 20;
                        m_A = 101;
                }
};

//子类----需要继承Library1和Library2
//class 子类 : 继承方式 父类1，继承方式 父类2....... 
class Book : public Library1, public Library2
{
        public:
                int m_C;
                int m_D;
                
                Book()
                {
                        m_C = 30;
                        m_D = 40;
                }
};

void test1()
{
        Book p1;
        
        cout << "size of p1 : " << sizeof(p1) << endl;
        
        //当父类中出现同名成员，需要加作用域区分 
        cout << "Library1::m_A : " << p1.Library1::m_A << endl;
        cout << "Library2::m_A : " << p1.Library2::m_A << endl;
}

int main()
{
        test1();
        
        return 0;
}

                                                    渣渣一个望各位大佬指点指点