CPP_继承_多态

C++面向对象的三大特性：封装，继承，多态。

封装：使用一整套方法去创建一个新的类型，这叫类的封装。

继承：从一个现有的类型基础上，稍作改动，得到一个新的类型的方法，叫类的继承。

多态：当有几个不同的子类对象时，对象调用的函数会依据对象类型来调用相应类型的成员函数。

1. 继承

继承的主要目的是为了代码复用。

class 子类: 继承方式 父类

子类也称派生类，父类也称基类。

1.1 访问权限：public, protected, private

protected表示这种成员可以被子类继承和访问，但是外界却像private一样不可访问。

父类的private成员并不是不继承，而是对子类扩展的成员函数不可见。

public派生规则：

父类成员访问权限	子类继承自父类成员的访问限定
public	public
protected	protected
private	不可见

protected派生规则:

父类成员访问权限	子类继承自父类成员的访问限定
public	protected
protected	protected
private	不可见

private派生规则:

父类成员访问权限	子类继承自父类成员的访问限定
public	private
protected	private
private	不可见

注：protected成员子类可访问，对象不可访问。

#include <iostream>
#include <string>
using namespace std;

class Animal
{
public:
    Animal(){m_id = 0;}
    Animal(int id){ m_id = id;}
    virtual void speak(){cout << "animal speak" <<endl;}

protected:
    int m_id;
};

//class Rabbit: protected Animal
class Rabbit: public Animal
{
public:
    Rabbit(int id){ m_id = id;}
    void speak(){cout << "dog speak " << m_id <<endl;}
};

void doSpeak(Animal &animal)
{
    animal.speak();
}

int main()
{
    Rabbit rab(1);
    doSpeak(rab); // Animal& animal = cat
    //doSpeak(rab); //protected报错：'Animal' is an inaccessible base of 'rabbit' 

    return 0;
}

1.2 继承中构造和析构顺序

创建子类对象时，先创建父类，再创建子类。
析构时，先析构子类，再析构父类。

1.3 继承中同名成员处理方式

当子类与父类出现同成员时，如何通过子类对象，访问到子类或父类中同名的数据呢？

• 访问子类同名成员，直接访问即可。
• 访问父类同名成员，需要加作用域。

s.m_A
s.Base::m_A
s.func();
s.Base::func()

注：如果子类出现和父类同名的成员函数，子类的同名成员函数会隐藏父类中所有的同名成员函数（包括父类中各种重载函数）。

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

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

• 访问子类同名成员，直接访问即可
• 访问父类同名成员，需要加作用域

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

1.5 菱形继承

两个派生类继承同一个基类，又有某个派生类同时继承这两个派生类，这种继承被称为菱形继承，或者钻石继承。

菱形继承问题

• 羊继承了动物的数据，驼同样继承了动物的数据，当羊驼使用数据时，就会产生二义性
• 羊驼继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以

菱形继承问题

虚继承：继承之前加上关键字virtual，变成虚继承。

#include <iostream>
using namespace std;

//动物类
class Animal
{
public:
    int m_Age;
};

//继承之前加上关键字virtual，变为虚继承
//Animal类称为 虚基类

//羊类
class Sheep :virtual public Animal {};
//驼类
class Camel :virtual public Animal {};
//羊驼类
class Alpaca :public Sheep, public Camel {};

int main()
{
    Alpaca alpaca;
    alpaca.Sheep::m_Age = 18;
    alpaca.Camel::m_Age = 28;
    //菱形继承时，两个父类拥有相同的数据，需要加以作用域区分
    //这份数据我们只需要一份，菱形继承导致数据有两份，造成资源浪费
    //利用虚继承解决菱形继承的问题
    cout << "alpaca.Sheep::m_Age = " << alpaca.Sheep::m_Age << endl;
    cout << "alpaca.Camel::m_Age = " << alpaca.Camel::m_Age << endl;
    cout << "alpace.m_Age = " << alpaca.m_Age << endl;

    return 0;
}
------
alpaca.Sheep::m_Age = 28
alpaca.Camel::m_Age = 28
alpace.m_Age = 28

1.6 类型转换

父类A 子类B

A *p = new B; 可以
B *p = new A; 不可以

p调用的成员方法为父类（A)的方法，非子类B的成员方法。属编译时绑定（因p的指针类型为A *），如要访问子类，需要使用多态（父类相应方法定义为virtual）。

A a;
B *p;
p = &a; 可以

p访问成员变量时可能越界（因p的成员变量多于a)。

2. 多态

2.1 动态多态

多态分为两类：静态多态和动态多态。

• 静态多态：函数重载和运算符重载属于静态多态，复用函数名。
• 动态多态：派生类和虚函数实现运行时多态。

区别

• 静态多态的函数地址早绑定--编译阶段确定函数地址。
• 动态多态的函数地址晚绑定--运行阶段确定函数地址。

动态多态满足条件

• 有继承关系
• 子类重写父类的虚函数（重写：函数返回值 函数名 参数列表 完全相同）

动态多态使用

父类的指针或引用指向子类的对象

#include <iostream>

using namespace std;

class Animal
{
public:
    void virtual speak(){  // 虚函数
        cout << "Animal speak" << endl;
    }
};

class Cat: public Animal
{
public:
// 重写：函数返回值、函数名、参数列表 完全相同
    void speak(){
        cout << "Cat speak" << endl;
    }
};

class Dog: public Animal
{
public:
    void speak(){
        cout << "Dog speak" << endl;
    }
};

// 地址早绑定，在编译阶段确定函数地址
// 如果想实现cat speak，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定--地址完绑定
// 父类中成员函数前加virtual
void doSpeak(Animal &animal)
{
    animal.speak();
}

int main()
{
    Cat cat;
    Dog dog;

    doSpeak(cat);
    doSpeak(dog);

    return 0;
}
-----------------
Cat speak
Dog speak

声明为vitual的成员函数称为虚函数，在运行时确定执行体，属动态绑定，dynamic binding，调用子类的具体实现。

一旦某个函数在父类中声明为virtual，在所有继承它的子类中这个函数也是virtual的，子类可以不必写virtual关键字。

多态原理

有虚函数的类都有一个隐含的指针成员vptr，指向一个虚函数表。（一个类一个）

每个父类或子类都各自有一张虚函数表。在构造对象时，对象的vptr成员指向该类的虚函数表vbtable(virtual base table)。

包含虚函数的类的sizeof应多加4个字节，用于存放vptr（虚函数表指针）。

2.2 纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要是调用子类重写的内容。因此可以将虚函数改为纯虚函数。

如果一个成员函数声明为virtual并在末尾加上=0而没有提供函数的实现，称为纯虚函数。拥有纯虚函数的类称为抽象类，抽象类不能实例化（或者说不能创建该类的对象），而只能被其他类继承。

纯虚函数语法：

virtual 返回值类型 函数名(参数列表)= 0;

抽象类特点：

• 无法实例化对象
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

抽象类也称为接口，继承了某个抽象类也称实现了某个接口。

#include <iostream>

using namespace std;

class CPU
{
public:
    virtual void calc() = 0;
};

class GPU
{
public:
    virtual void display() = 0;
};

class RAM
{
public:
    virtual void store() = 0;
};

class Computer
{
public:
    Computer(CPU *cpu, GPU *gpu, RAM * ram);
    void doWrok();
    ~Computer();



    CPU* cpu_;
    GPU* gpu_;
    RAM* ram_;
};

Computer::Computer(CPU* cpu, GPU* gpu, RAM* ram)
{
    cpu_ = cpu;
    gpu_ = gpu;
    ram_ = ram;
}

void Computer::doWrok()
{
    cpu_->calc();
    gpu_->display();
    ram_->store();
}

Computer::~Computer()
{
    if(cpu_ != NULL){
        delete cpu_;
        cpu_ = NULL;
    }

    if(gpu_ != NULL){
        delete gpu_;
        gpu_ = NULL;
    }
    
    if(ram_ != NULL){
        delete ram_;
        ram_ = NULL;
    }
}

class IntelCpu : public CPU
{
    virtual void calc(){
        cout << "Intel CPU" << endl;
    }
};

class AmdCpu : public CPU
{
    virtual void calc(){
        cout << "AMD CPU" << endl;
    }
};

class NvidiaGpu: public GPU
{
    void display(){
        cout << "Nvidia GPU" << endl;
    }
};

class AmdGpu: public GPU
{
    void display(){
        cout << "AMD GPU" << endl;
    }
};

class CorsairRam: public RAM
{
    void store(){
        cout << "Corsair RAM" << endl;
    }
};

class GskillRam: public RAM
{
    void store(){
        cout << "Gskill RAM" << endl;
    }
};

int main(int argc, const char *argv[])
{
    CPU *tIntelCpu = new IntelCpu;
    GPU *tNvidiaGpu = new NvidiaGpu;
    RAM *tCorsairRam = new CorsairRam;

    cout << "first Computer" << endl;
    Computer *tcomputer = new Computer(tIntelCpu, tNvidiaGpu, tCorsairRam);
    tcomputer->doWrok();

    cout << "------------------------------" << endl;
    Computer *scomputer = new Computer(new AmdCpu, new AmdGpu, new GskillRam);
    scomputer->doWrok();
    
    return 0;
}

2.3 虚析构和纯虚析

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。解决方法：将父类中的析构函数改为虚析构或纯虚析构。

虚析构和纯虚析构共性：

• 可以解决父类指针释放子类对象
• 都需要有具体的函数实现

虚析构和纯虚析构区别：

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

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名(){} = 0；
类名::~类名(){}

注：如果子类中没有堆区数据，可以不写虚析构或纯虚析构。

#include <iostream>

using namespace std;

class Animal
{
public:
    Animal(){cout << "Animal constructor" << endl;}
    //纯虚函数
    void virtual speak() = 0;
    //利用虚析构可以解决父类指针释放子类对象时不干净的问题
    //virtual ~Animal(){cout << "Animal destructor"}
    virtual ~Animal() = 0; //纯虚析构：需要声明，也需要具体实现
};

Animal::~Animal()
{
    cout << "Animal pure virtual deconstructor" << endl;
}

class Cat: public Animal
{
public:
    Cat(string name){
        cout <<"Cat constructor" << endl;
        m_Name = new string(name);
    }
    void speak(){
        cout << *this->m_Name << " cat speak" << endl;
    }
    ~Cat(){
        if(m_Name != NULL){
            cout << "free cat memory" << endl;
            delete m_Name;
            m_Name = NULL;
        }
    }

    string *m_Name;
};

int main()
{
    Animal *animal = new Cat("Tom");
    animal->speak();

    //父类指针析构时不会调用子类析构函数，导致如果子类有堆区数据，造成内存泄漏
    delete animal;

    return 0;
}
------------------
Animal constructor
Cat constructor
Tom cat speak
free cat memory
Animal pure virtual deconstructor