浅谈如何理解C++中的虚函数与纯虚函数

总所周知，虚函数是运行时的多态，虚函数只负责基类定义，而派生函数则进行重写实现。而纯虚函数就更为优秀了，只需要加个=0参数，就等于我定义了，派生类负责实现。我们先介绍虚函数再介绍纯虚函数。
虚函数一般分为虚函数成员与虚析构函数。

虚函数成员就是指派生类对基类虚函数重新定义，但仍作为虚函数可在更下层派生类中重新定义。

#include
using namespace std;
class Animal{
public:
    virtual void speak() {
        cout << "animal language!" << endl;
    }//虚函数成员
};

class Cat:public Animal{
public:
    virtual void speak(){
        cout << "cat language:miaomiao!" << endl;
    }//虚函数成员出现
};

int main()
{
    Cat cat;
    Animal *panimal = &cat;
    Animal &ref = cat;
    panimal->speak();
    ref.speak();
    return 0;

}

比如在这段程序里派生类就是对虚函数进行重新定义。毫无疑问答案就是。

虚析构函数的出现就是基类指针指向派生类指针，如果基类指针被析构，顺便把派生类也析构的作用。

#include
#include 

using namespace std;

class Animal{
public:
    Animal(char *name);
    void print_name();
    virtual void print_color();
    virtual void speak();
    virtual ~Animal();
private:
    char *m_pAnimalName;
};

Animal::Animal(char *name) {
    int len = strlen(name)+1;
    m_pAnimalName = new char[len];
    strcpy_s(m_pAnimalName,len,name);
}

Animal::~Animal() {
    cout << "Animal destructor!" << endl;
    if(m_pAnimalName){
        delete[] m_pAnimalName;
    }
}

void Animal::print_name() {
    cout << "name:" << m_pAnimalName << endl;
}

void Animal::print_color() {

}

void Animal::speak() {
}

class Cat:public Animal{
public:
    Cat(char* name,char* catcolor);
    virtual void print_color();
    virtual void speak();
    virtual ~Cat();
private:
    char *m_pCatColor;
};

Cat::Cat(char *name,char *color):Animal(name){
    cout << "Cat connstructor" << endl;
    m_pCatColor = new char[strlen(color) +1];
    strcpy_s(m_pCatColor, strlen(color)+1,color);

}
Cat::~Cat(){
    cout << "Cat destructor!" << endl;
    if(m_pCatColor){
        delete []m_pCatColor;
    }
}

void Cat::print_color() {
    cout << "cat color:" << m_pCatColor << endl;
}

void Cat::speak(){
    cout << "cat lanauge miaomiao!" << endl;
}

int main()
{
    Animal *p[2];
    int i;
    p[0] = new Cat("short_haired","white");
    p[0]->print_color();
    p[0]->print_name();
    p[0]->speak();
    p[1] = new Cat("Persian_cat","brown");
    p[1]->print_name();
    p[1]->print_color();
    for(i=0;i<2;i++)
        delete p[i];

    return 0;

}

比如在这段程序里，纯虚函数，就是在啊析构的时候一并析构了。

纯虚函数就是将基类的虚函数增加一个=0，实现就在派生类实现即可。

virtual void print_color()=0;

#include
#include
using namespace std;

class Animal{
public:
    Animal(char *name);
    void print_name();
    virtual void print_color() = 0;
    virtual ~Animal();
private:
    char *m_pAnimalName;
};

Animal::Animal(char *name) {
    int len = strlen(name)+1;
    m_pAnimalName = new char[len];
    strcpy_s(m_pAnimalName,len,name);
}

Animal::~Animal() {
    cout << "Animal destructor!" << endl;
    if(m_pAnimalName){
        delete []m_pAnimalName;
    }
}

void Animal::print_name() {
    cout << "name:" << m_pAnimalName << endl;
}

class Cat:public Animal{
public:
    Cat(char *name,char *catcolor);
    virtual void print_color();
    virtual ~Cat();
private:
    char *m_pCatColor;

};

Cat::Cat(char *name,char *color): Animal(name){
    cout << "Cat constructor!" << endl;
    m_pCatColor = new char[strlen(color) +1];
    strcpy_s(m_pCatColor,strlen(color) + 1,color);
}

Cat::~Cat(){
    cout << "Cat destructor!" << endl;
    if(m_pCatColor) {
        delete []m_pCatColor;
    }
}
void Cat::print_color() {
    cout << "cat color:" << m_pCatColor << endl;
}

int main()
{
    Animal *p;
    p = new Cat("short_cat","white");
    p->print_name();
    p->print_color();
    cout << "----------------" << endl;
    delete p;
    return 0;

}

基类声明，派生类进行重定义。

虚函数分为一般虚函数成员与虚析构函数。其中虚一般成员函数就是基类定义，派生类进行重定义用的，而虚析构函数就是指基类指针指向派生类指针，如果基类指针指向派生类new分配，基类指针析构，派生类无法析构的问题。而纯虚函数就是只是提供函数接口，派生类根据给出具体实现。