C++学习笔记-day12

1、继承的基本语法

 

 

#include<iostream>
using namespace std;


//普通实现页面

//Java页面

//class Java
//{
//public:
//    void head()
//    {
//        cout << "公共头部" << endl;
//    }
//    void footer()
//    {
//        cout << "公告底部" << endl;
//    }
//    void left()
//    {
//        cout << "公告分类列表" << endl;
//    }
//    void content()
//    {
//        cout << "java视频" << endl;
//    }
//};
//
//class Python
//{
//public:
//    void head()
//    {
//        cout << "公共头部" << endl;
//    }
//    void footer()
//    {
//        cout << "公告底部" << endl;
//    }
//    void left()
//    {
//        cout << "公告分类列表" << endl;
//    }
//    void content()
//    {
//        cout << "python视频" << endl;
//    }
//};

//继承实现页面

class Base
{
public:
    void head()
    {
        cout << "公共头部" << endl;
    }
    void footer()
    {
        cout << "公告底部" << endl;
    }
    void left()
    {
        cout << "公告分类列表" << endl;
    }
};

//继承好处：减少重复的代码

//class 子类：继承方式 父类
//子类也称为派生类 父类也称为基类  
class Java: public Base 
{
public:
    
        void content()
    {
        cout << "java视频" << endl;
    }
};
class Python : public Base
{
public:
    void content()
    {
        cout << "python视频" << endl;
    }
};

void test01()
{
    cout << "java视频页面如下" << endl;

    Java j;
    j.head();
    j.footer();
    j.left();
    j.content();

    cout << "*********" << endl;
    cout << "python视频页面如下" << endl;

    Python p;
    p.head();
    p.footer();
    p.left();
    p.content();
}
int main()
{
    test01();

    system("pause");
    return 0;
}

2、继承方式

 

 

 

 

#include<iostream>

using namespace std;

class Base1
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class son1 :public Base1
{
public:
    void func()
    {
        //父类中公共权限到子类依然是公共权限
        m_A = 10;
        //父类中保护权限到子类依然是保护权限
        m_B = 10;
        //父类中私有权限 子类访问不到
        //m_C = 10;
    }
};

//保护继承


class son2 :protected Base1
{
public:
    void func()
    {
        //父类中公共权限到子类是保护权限
        m_A = 10;
        //父类中保护权限到子类依然是保护权限
        m_B = 10;
        //父类中私有权限 子类访问不到
        //m_C = 10;
    }
};

class son3 :private Base1
{
public:
    void func()
    {
        //父类中公共权限到子类是私有权限
        m_A = 10;
        //父类中保护权限到子类依然是私有权限
        m_B = 10;
        //父类中私有权限 子类访问不到
        //m_C = 10;
    }
};

class grandson3 :public son3
{
public:
    void func()
    {
        //父类中私有权限 子类访问不到
        //m_A = 10;
        //父类中私有权限 子类访问不到
        //m_B = 10;
        //父类中私有权限 子类访问不到
        //m_C = 10;
    }
};

void test01()
{
    son1  s1;
    s1.m_A = 100;

    //保护权限类外不可访问
    //s1.m_B = 100;

    son2  s2;
    //保护权限类外不可访问
    //s2.m_A = 100;
    son3  s3;
    //私有权限类外不可访问
    //s3.m_A = 100;

}

int main()
{

    system("pause");
    return 0;
}

3、继承中的对象模型

父类中私有成员也是被子类继承下去了，只是编译器隐藏访问不到

#include<iostream>
using namespace std;


class base1
{
public:
    int m_a;
protected:
    int m_b;
private:
    int m_c;
};

class son1 :public base1
{
public:
    int m_d;
    
};

void test1()
{
    //父类中的非静态成员属性都会被子类继承下去
    //父类的私有属性被编译器隐藏了，但是确实被继承下去了
    cout << sizeof(son1) << endl;
}

int main()
{
    test1();
    system("pause");
    return 0;
}

 4、继承中的构造和析构顺序

构造 先构造父亲再构造儿子

析构 先析构儿子再析构父亲

 

5、继承同名成员处理

 

 

 

 6、继承同名静态成员处理方式

同名的静态成员处理方式和非静态成员处理方式是一样的，只不过有两种访问方式，通过对象和通过类名。

 

7、多继承语法

 

 多继承中如果父类出现了同名的情况，子类使用时要加作用域

8、菱形继承

 

 

#include<iostream>
using namespace std;

//动物类

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 << endl;

    //这份数据我们只需要知道一份就可以了，菱形继承导致数据有两份，导致资源浪费
}

int main()
{

    test01();

    system("pause");
    return 0;
}