继承

面向对象的语法思想都差不多继承的好处就是方便

语法： class 子类 : 继承方式 父类

继承方式

公共继承：继承的内容权限不变

保护继承：继承的内容权限变为protected

私有继承：继承的内容权限变为private

这三类继承都不可访问父类中private的内容（还是被继承了）

继承中构造和析构顺序

先构造父类，再构造子类，析构顺序与构造顺序相反。

继承同名成员处理方式

访问子类同名成员 直接访问即可

访问父类同名成员 需要加作用域

class base {
public:
    int a=100;
};
class son:public base {
public:
    int a=200;
};
void test() {
    son s;
    cout<<s.a<<endl; //200
    cout<<s.base::a<<endl; //100 加作用域调用父类同名成员
}

当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

多继承

C++中允许一个类继承多个类，这点和Java不一样

语法：class 子类::继承方式 父类1 , 继承方式 父类2...

多继承可能引发父类中有同名成员的出现，需要加作用域区分.实际开发中不建议使用

class Base1 {
public:
    Base1() {
        m_A = 100;
    }
    int m_A;
};
class Base2 {
public:
    Base2() {
        m_B = 100;
    }
    int m_B;
};

class Son :public Base1,public Base2 {
public:
    Son() {
        m_C = 300;
        m_D = 400;
    }
    int m_C;
    int m_D;
};

void test1() {
    Son s;
    cout<<sizeof(s)<<endl; //16 4个int
}

虚继承

在继承之前加上关键字virtual

。。。。

多态

多态分为两类：

静态多态：函数重载和运算符重载

动态多态：派生类和虚函数实现运行时多态

两者区别

静态多态的函数地址早绑定 - 编译阶段确定函数地址

动态堕胎的函数地址晚绑定 - 运行阶段确定函数地址

class Animal {
public:
    void speak() {
        cout<<"11"<<endl;
    }
};
class Cat:public Animal {
public:
    void speak() {
        cout<<"22"<<endl;
    }
};
void doSpeak(Animal &animal) {
    //执行的是animal的speak 原因是地址早绑定 在编译阶段就已确定
    animal.speak(); //11
}
void test01() {
    Cat cat;
    doSpeak(cat); //11
}

动态多态满足条件

1.要有继承关系

2.子类重写父类中的虚函数

动态多态使用

父类的指针或者引用 执行子类对象

class Animal {
public:
    //虚函数
    virtual void speak() {
        cout<<"11"<<endl;
    }
};
class Cat:public Animal {
public:
    void speak() {
        cout<<"22"<<endl;
    }
};
void doSpeak(Animal &animal) {
    //如果想执行猫说话就需要晚绑定通过将animal中的speak函数变为虚函数来实现
    animal.speak(); //22
}

纯虚函数

通常父类中的虚函数的实现是毫无意义的，主要是调用子类重写的内容

因此可将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）=0

重写纯虚函数时 也需要加上virtual

抽象类

当类中有了纯虚函数，这个类就是抽象类

特点

（和Java差不多）

无法实例化对象

子类必须重写抽象类中的纯虚函数，否则也属于抽象类

虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

class Animal {
public:
    //虚函数
    virtual void speak() = 0;
};
class Cat:public Animal {
public:
    Cat(string name) {
        this->name = new string(name);
    }
    virtual void speak() {
        cout<<"22"<<endl;
    }
    ~Cat() {
        if(name!=NULL) {
            cout<<"cat析构"<<endl;
            delete name;
            name = NULL;
        }
    }
    string * name;
};
void doSpeak(Animal &animal) {
    //执行的是animal的speak 原因是地址早绑定 在编译阶段就已确定
    animal.speak(); //11
    //如果想执行猫说话就需要晚绑定通过将animal中的speak函数变为虚函数来实现
    animal.speak();
}
void test() {
    Animal * a = new Cat("Tom");
    a ->speak();
    delete a;   //Cat的析构函数没有触发
    //问题：delete父类指针时 不会调用子类的析构 导致子类堆区会有泄露的情况
}

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构

class Animal {
public:
    //虚函数
    virtual void speak() = 0;

    //虚析构
    virtual ~Animal() {
        cout<<"xuxigou"<<endl;
    };
};

纯虚析构

class Animal {
public:
    //虚函数
    virtual void speak() = 0;
    
    //纯虚析构
    virtual ~Animal() = 0;
};
//纯虚析构要有声明也要有实现
Animal:: ~Animal() {
   cout<<"纯虚析构"<<endl;
};

两者共性：

可以解决父类指针释放子类对象

都需要具体函数实现

区别：

如果是纯虚析构，该类属于抽象类，无法实例化对象