3、继承

最新推荐文章于 2022-11-19 11:24:34 发布

沉城

最新推荐文章于 2022-11-19 11:24:34 发布

阅读量126

点赞数

分类专栏： C++

C++ 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

单个类的访问控制
Public 在类内，类外可以访问；
Protected 类的内部，子类种可以使用
Private 类的内部

【1】派生类的访问控制

Public：
公用继承：子类中的属性为父类中的属性

Proteced: public proteced 变为proteced（子类的内部使用） Private ：Private

Private：
私有继承：子类中的属性全部变为私有（在子类中不可使用）

派生类的访问控制三看原则
1看：调用是写在子类的内部还是外部（main）
2看：看子类如何从父类里面继承（child）
3看：看父类中的访问级别（parent）

【2】类型兼容原则
在基类对象的任何地方，都可以使用公有派生类的对象来代替

1子类对象可以当作父类对象使用 【第二层】
2子类对象可以直接赋值给父类  【第二层】
3子类对象可以直接初始化父类 【第二层】

4父类指针可以指向子类对象 【第一层】
5父类引用可以直接指向子类对象【第一层】

【第一层含义】父类指针（引用）指向子类对象

【第二层含义】子类对象初始化父类对象

【3】继承中的对象模型
子类包含父类所有成员变量和方法，调用看访问控制

【4】继承中的构造函数和析构

在子类对象构造时，需要调用父类构造函数对其继承得来的成员进行初始化（通过构造函数初始化列表）
在子类对象析构时，需要调用父类析构函数对其继承得来的成员进行清理

【5】先调用父类构造—>子类的构造
析构相反

【6】继承和组合搭配下的构造和析构函数
先调用祖先构造–>混搭构造–>自己构造
析构相反


#include <iostream>
using namespace std;

class Object
{
public:
    Object(int a, int b)
    {
        this->a = a;
        this->b = b;
        cout<<"object构造函数 执行 "<<"a"<<a<<" b "<<b<<endl;
    }
    ~Object()
    {
        cout<<"object析构函数 \n";
    }
protected:
    int a;
    int b;
};


class Parent : public Object
{
public:
    Parent(char *p) : Object(1, 2)
    {
        this->p = p;
        cout<<"父类构造函数..."<<p<<endl;
    }
    ~Parent()
    {
        cout<<"析构函数..."<<p<<endl;
    }

    void printP(int a, int b)
    {
        cout<<"我是爹..."<<endl;
    }

protected:
    char *p;

};


class child : public Parent
{
public:
    child(char *p) : Parent(p) , obj1(3, 4), obj2(5, 6)//构造函数初始化列表
    {
        this->myp = p;
        cout<<"子类的构造函数"<<myp<<endl;
    }
    ~child()
    {
        cout<<"子类的析构"<<myp<<endl;
    }
    void printC()
    {
        cout<<"我是儿子"<<endl;
    }
protected:
    char *myp;
    Object obj1;
    Object obj2;
};


void objplay()
{
    child c1("继承测试");
}
void main()
{
    objplay();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

【7】继承中的同名成员变量和同名成员函数
默认情况是子类的，想使用父类的用作用域

    Child c;
    //1.父类和子类有同名函数，直接访问子类
    //2.可以通过域名的方法访问父类的同名函数
    cout << c.a<< endl;
    cout <<c.Father::a << endl;

【8】派生类中的static关键字
遵循类的访问控制

1按照正常的static成员分配空间和操作
2使用域名访问
3都可以被继承到派生类里面，只要子类里面有重名都会隐藏父类里面的

多继承


#include <iostream>
using namespace std;

class Base1
{
public:
    Base1(int b1)
    {
        this->b1 = b1;
    }
    void printB1()
    {
        cout<<"b1:"<<b1<<endl; 
    }
protected:
private:
    int  b1;
};

class Base2
{
public:
    Base2(int b2)
    {
        this->b2 = b2;
    }
    void printB2()
    {
        cout<<"b2:"<<b2<<endl; 
    }
protected:
private:
    int  b2;
};

class B : public Base1, public Base2
{
public:
    B(int b1, int b2, int c): Base1(b1), Base2(b2)
    {
        this->c = c;
    }
    void printC()
    {
        cout<<"c:"<<c<<endl; 
    }
protected:
private:
    int c;
};

void main()
{
    B b1(1, 2, 3);
    b1.printC();
    b1.printB1();
    b1.printB2();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

多继承的二义性虚继承解决二义性


#include <iostream>
using namespace std;

class B
{
public:
    int b;
protected:
private:

};

class B1 : virtual public B
{
public:
    int b1;

};

class B2 : virtual  public B
{
public:
    int b2;
};

class C : public B1, public B2
{
public:
    int c;
};

void main()
{

    C  c1;
    c1.b1 = 100;
    c1.b2 = 200;
    c1.c = 300;

    c1.b = 500; //继承的二义性 和 虚继承解决方案
    //c1.B1::b = 500;
    //c1.B2::b = 500;


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}