抽象方法与多态性——C++（25）

抽象方法

• 抽象方法，也可以称为纯虚函数。是面向对象编程技术的另一个核心概念。在设计一个多层次的类继承关系常会用到。

• 把一个方法说明为一个抽象方法，等于告诉编译器： 这个方法必不可少。但我现在在这个基类里还不能为他提供一个实现。**

• 抽象方法的语法很简单，在声明一个虚方法的基础上，在原先的末尾上加上“=0”。 （告诉这个编译器不用浪费时间在这个类里寻找这个方法的实现）

总结理解

• 抽象方法就是在虚方法的后面加上 “=0”
• 声明为虚方法就是告诉编译器：在分配内存的时候，要根据指针不同的类型来调用正确的方法。
• 声明为抽象方法就是告诉编译器：在当前这个基类不能实现，去忙别的。

多态性

• 多态性：是指用一个名字定义不同的函数，调用同一个名字的函数，却执行不同的操作，从而实现传说中的“一个接口，多种方法”。

• 多态是如何实现绑定的？
  ----编译时的多态性：通过重载实现。
  ----运行时的多态性：通过虚方法实现。

进一步理解析构函数

• 一般类的析构函数都是释放内存资源，如果析构函数不被调用的话将会造成内存泄漏。

• 析构器定义为虚方法是为了当一个基类的指针删除一个派生类的对象时，派生类的析构函数可以被正确调用。

代码实现

抽象函数部分：

//int *pointer = new int;//声明一个整型指针，并在程序运行时将它指向分配的内存空间 
//delect *pointer;//删除指针，释放内存 
#include <iostream>
#include <string>

using namespace std;

class Pet//定义Pet类 
{
public:
    Pet(string theName);//构造器,对count进行写操作 
    
    virtual void eat();
    virtual void sleep();
    virtual void play() = 0;//定义抽象方法play,具体只需在继承类中声明实现即可，基类中不需要具体实现 
    
protected://不允许没有继承Pet类的其它类调用 
    string name;
};
Pet::Pet(string theName)
{
    name = theName;
}
void Pet::eat()
{
    cout << name << "正在吃东西！\n";
}
void Pet::sleep()
{
    cout << name << "正在睡大觉！\n";
}

class Cat:public Pet//定义Cat类继承于Pet类 
{
public:
    Cat(string theName);//构造器
    
    void climb();
    void play();
};
Cat::Cat(string theName):Pet(theName)//Cat的构造函数继承于Pet类中的Pet(theName)函数
{
}
void Cat::climb()
{
    cout << name << "正在爬树！\n";
}
void Cat::play()
{
    cout << name << "玩毛绒球！\n";
}

class Dog:public Pet//定义Dog类继承于Pet类 
{
public:
    Dog(string theName);//构造器
    
    void bark();
    void play();
};
Dog::Dog(string theName):Pet(theName)//Dog的构造函数继承于Pet类中的Pet(theName)函数
{
}
void Dog::bark()
{
    cout << name << "汪汪汪！\n";
}
void Dog::play()
{
    //Pet::play();
    cout << name << "正在追赶那只该死的猫！\n";
}
int main()
{
    Pet *cat = new Cat("加菲");
    Pet *dog = new Dog("欧迪");
    
    cat -> sleep();
    cat -> eat();
    cat -> play();
    
    dog -> sleep();
    dog -> eat();
    dog -> play();
    
    delete cat;
    delete dog;
    
    return 0;
 }

析构函数部分

#include <iostream>
//析构器都是虚方法 
using namespace std;

class ClxBase//定义基类ClxBase 
{
public:
    ClxBase()//构造器 
    {
        cout << "ClxBase begin!\n";
    };
    virtual ~ClxBase()//析构器 ，如果其不为虚函数，则子类的析构函数将不被执行,将造成内存泄漏 
    {
        cout << "ClxBase end!\n"; 
    };
    virtual void doSomething()//定义抽象方法doSomething 具体只需在继承类中声明实现即可(便可覆盖基类中定义)，基类中可以不具体实现 
    {
        cout << "Do something in class ClxBase!\n"; 
    }
};

class ClxDerived:public ClxBase//定义子类ClxDerived继承于基类ClxBase 
{
public:
    ClxDerived()//子类构造器 
    {
        cout << "ClxDerived begin!\n";
    };
    ~ClxDerived()//子类析构器 
    {
        cout << "Output from the destructor of class ClxDerived!\n";
    };
    void doSomething()
    {
        cout << "Do something in class ClxDerived!\n";
    };
};

int main()
{
    ClxBase *pTest = new ClxDerived;//定义一个pTest指针指向继承于ClxBase的ClxDerived对象，并为此指针分配内存 
    pTest -> doSomething();
    
    delete pTest;
    
    return 0;
}