c++ 普通函数、虚函数、纯虚函数的区别

1.虚函数(impure virtual)

　　C++的虚函数主要作用是“运行时多态”，父类中提供虚函数的实现，为子类提供默认的函数实现。
　　子类可以重写父类的虚函数实现子类的特殊化。
　　如下就是一个父类中的虚函数：
　　

class Base{

public :
    void foo();//普通函数

    virtual void foo1();//虚函数


    Base();
    ~Base();

};

2.纯虚函数(pure virtual)

　　C++中包含纯虚函数的类，被称为是“抽象类”。抽象类不能使用new出对象，只有实现了这个纯虚函数的子类才能new出对象。
　　C++中的纯虚函数更像是“只提供申明，没有实现”，是对子类的约束，是“接口继承”。
　　C++中的纯虚函数也是一种“运行时多态”。
　　如下面的类包含纯虚函数，就是“抽象类”：
　　

class Base{

public :
    void foo();//普通函数

    virtual void foo1();//虚函数

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

    Base();
    ~Base();

};

含有纯虚函数的类，为抽象类，不能实例化 ~Base *base = new Base();~
3.普通函数(no-virtual)
　　普通函数是静态编译的，没有运行时多态，只会根据指针或引用的“字面值”类对象，调用自己的普通函数。
　　普通函数是父类为子类提供的“强制实现”。
　　因此，在继承关系中，子类不应该重写父类的普通函数，因为函数的调用至于类对象的字面值有关。

4.测试代码：
头文件如下

#ifndef _BASE_H__
#define _BASE_H__
#include <stdio.h>

class Base{

public :
    void foo();//普通函数

    virtual void foo1();//虚函数

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

    Base();
    ~Base();

};

class Child :public Base{
public :
    void foo();//普通函数

    virtual void foo1();//虚函数

    virtual void foo2();//虚函数   

    Child();
    ~Child();
};

class Child1 :public Base{

public :
    void foo();//普通函数

    virtual void foo1();//虚函数

    virtual void foo2();//虚函数

    Child1();
    ~Child1();

};

cpp文件如下：

#include "base.h"

void Base::foo(){
    printf("%s\n", "base-foo");

};
void Base::foo1(){
    printf("%s\n", "base-foo1");
}
void Base::foo2(){
    printf("%s\n", "base-foo2");
}
Base::Base(){
}
Base::~Base(){
}



void Child::foo(){
//不建议重写
    printf("%s\n", "Child-foo");
}

void Child::foo1(){

    printf("%s\n", "Child-foo1");
}

void Child::foo2(){

    printf("%s\n", "Child-foo2");

}
Child::Child(){
}

Child::~Child(){
}



void Child1::foo(){
//不建议重写
    printf("%s\n", "Child1-foo");
}
void Child1::foo1(){
    printf("%s\n", "Child1-foo1");
}

void Child1::foo2(){
    printf("%s\n", "Child1-foo2");

}
Child1::Child1(){

}
Child1::~Child1(){

}

测试代码：

#include "dao.h"
#include "base.h"
#include <iostream>
using namespace std;


int _tmain(int argc, _TCHAR* argv[])
{

    Base * bchild = new Child();
    Base *bchild1 = new Child1();
    Child *cchild = new Child();
    Child1 *cchild1 = new Child1();

    bchild ->foo();
    bchild ->foo1();
    bchild ->foo2();
    cout << "____________________" << endl;
    bchild1 ->foo();
    bchild1 ->foo1();
    bchild1 ->foo2();

    cout << "____________________" << endl;
    cchild->foo();
    cchild->foo1();
    cchild->foo2();
    cout << "____________________" << endl;
    cchild1->foo();
    cchild1->foo1();
    cchild1->foo2();
}

测试结果：

深入了解可参考这篇博客：这里写链接内容