C++黑马程序员——P138,140. 纯虚函数和抽象类，虚析构和纯虚析构

• P138. 类和对象——多态——纯虚函数和抽象类
• P140. 类和对象——多态——虚析构和纯虚析构
• P138. 纯虚函数和抽象类

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

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

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

当类中有了纯虚函数，这个类称为抽象类

抽象类特点：

● 无法实例化对象

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

//纯虚函数和抽象类
class Base
{
public:
    //纯虚函数
    //只要有一个纯虚函数，这个类就是抽象类：无法实例化对象
    virtual void func() = 0;
};

class Son :public Base
{
public:
    //子类必须重写父类中的纯虚函数，否则也属于抽象类
    virtual void func()
    {
        cout << "Son 的 func() 调用" << endl;
    }
};

void test01()
{
    //Base b1;    //报错，抽象类无法实例化对象
    //new Base;    //报错，抽象类无法实例化对象，堆区也不行
    
    //使用 多态 调用子类的函数
    Base* base = new Son;
    base->func();
}

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

运行结果：

　　

 

• P140. 虚析构和纯虚析构

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

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

 

虚析构和纯虚析构共性：

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

● 都需要有具体的函数实现

 

虚析构和纯虚析构区别：

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

class Animal
{
public:
    Animal()
    {
        cout << "Animal 构造函数调用" << endl;
    }

    ~Animal()
    {
        cout << "Animal 析构函数调用" << endl;
    }

    //纯虚函数
    virtual void speak() = 0;
};

class Cat:public Animal
{
public:
    Cat(string name)
    {
        cout << "Cat 构造函数调用" << endl;
        m_Name = new string(name);
    }

    ~Cat()
    {
        cout << "Cat 析构函数调用" << endl;
        if (m_Name != NULL)
        {
            delete m_Name;
            m_Name = NULL;
        }
    }

    virtual void speak()
    {
        cout << *m_Name << " Cat speak" << endl;
    }
    string* m_Name;
};

void test01()
{
    Animal* animal = new Cat("Tom");
    animal->speak();
    delete animal;
}

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

运行结果：

　　

出现的问题：释放 animal 指针时，没有调用子类中的析构函数，子类中堆区的数据（m_Name）没有被释放，导致内存泄漏。（父类指针在析构时候，不会调用子类中析构函数）

 

虚析构语法：

virtual ~类名（）{}

纯虚析构语法：

virtual ~类名（）= 0；

类名 :: ~类名（）{}（纯虚析构 在类外需要有具体的函数实现）

 

把上面 Animal 的析构函数改成虚析构：

    //虚析构; 利用虚析构可以解决 父类指针释放子类对象时不干净的问题
    virtual ~Animal()
    {
        cout << "Animal 析构函数调用" << endl;
    }

运行结果：

　　

 

把 Animal 的析构函数改成纯虚析构也可以：

class Animal
{
public:
    Animal()
    {
        cout << "Animal 构造函数调用" << endl;
    }

    //纯虚析构，需要声明也需要实现 (在类外要有具体的实现，否则运行会报错)
    //有了纯虚析构之后，这个类也属于抽象类，无法实例化对象
    virtual ~Animal() = 0;

    //纯虚函数
    virtual void speak() = 0;
};

Animal::~Animal()
{
    cout << "~Animal 的纯虚析构调用" << endl;
}

运行结果：

　　

 

总结：

1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象

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

3. 拥有纯虚析构函数的类也属于抽象类

(〃＞＿＜;〃)(〃＞＿＜;〃)(〃＞＿＜;〃)