首先：强调一个概念

1. 定义一个函数为虚函数，不代表函数为不被实现的函数。 定义它为虚函数是 为了允许用基类的指针来调用子类的这个函数 , 也就是 虚函数是指一个类中你希望重载的成员函数 ，当你用一个 基类指针或引用 指向一个子类对象的时候，调用一个虚函数时, 实际调用的是子类的版本。
2. 定义一个函数为纯虚函数，才代表函数没有被实现。

定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。

一、虚函数

1.虚函数定义

在基类中实现虚函数的方法是在函数原型前面增加 virtual.

virtual void funtion1();

虚函数的虚就虚在所谓"推迟联编"或者"动态联编"上，一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被成为"虚"函数。
虚函数只能借助于指针或者引用来达到多态的效果。

二、纯虚函数

1.纯虚函数定义：

纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型前面增加 virtual ，后面加 =0 。

virtual void funtion1()=0

2.纯虚函数的引入原因

1. 为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。
2. 在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。

3.纯虚函数意义

定义纯虚函数的目的在于，使派生类仅仅只是继承函数的接口。

纯虚函数的意义：让所有的类对象（主要是派生类对象）都可以执行纯虚函数的动作，但类无法为纯虚函数提供一个合理的默认实现。所以类纯虚函数的声明就是在告诉子类的设计者，“你必须提供一个纯虚函数的实现，但我不知道你会怎样实现它”。

三、举例

1.测试源代码

test_virtual.cpp 内容：

#include <iostream>using  namespace std;
class Parent
{    
 public:
     char data[20];
     void Function1();    
     virtual void Function2();   // 这里声明Function2是虚函数
     
 }parent;
 void Parent::Function1()
 {
     printf("This is parent,function1\n");
 }
 void Parent::Function2()
 {
     printf("This is parent,function2\n");
 }
 
 class Child:public Parent
 {
     void Function1();
     void Function2();
     
 } child;
 void Child::Function1()
 {
     printf("This is child,function1\n");
 }
 void Child::Function2()
 {
     printf("This is child,function2\n");
 }
 
 int main(int argc, char* argv[])
 {
     Parent *p;// 定义一个基类指针
     printf("请输入一个字符:");
     if(getchar()=='c')// 如果输入一个小写字母c    
         p=&child;// 指向继承类对象
     else    
         p=&parent;// 否则指向基类对象
     printf("函数调用情况:\n");
     p->Function1();// 这里在编译时会直接给出Parent::Function1()的入口地址。    
     p->Function2();// 注意这里，执行的是哪一个Function2
     return 0;
 }

CMakeLists.txt

cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
project(test_virtual)
set(CMAKE_BUILD_TYPE "Debug")
add_executable (test_virtual src/test_virtual.cpp)

2.运行效果

• 如果输入字符c
  结果分析：
  为什么会有第一行的结果呢？
  因为我们是用一个Parent类的指针调用函数Fuction1()，虽然实际上这个指针指向的是Child类的对象，但编译器无法知道这一事实（直到运行的时候，程序才可以根据用户的输入判断出指针指向的对象），它只能按照调用Parent类的函数来理解并编译，所以我们看到了第一行的结果。
  那么第二行的结果又是怎么回事呢？我们注意到，Function2()函数在基类中被virtual关键字修饰，也就是说，它是一个虚函数。
• 如果输入其他字符
  

请注意看第二行，它的结果出现了变化。程序中仅仅调用了一个Function2()函数，却可以根据用户的输入自动决定到底调用基类中的Function2还是继承类中的Function2，这就是虚函数的作用。

PS:一定要注意“ 静态联翩 ”和“ 动态联编 ”的区别（ 动态联编 ：一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。）；对于我来说，若没有亲自去测试，凭自己的感觉，
当在键盘中输入“c”时，我会觉得由于有p=&child;这一句代码，我会认为结果都是：

This is child,function1
This is child,function2

但是结果却是：

This is parent,function1
This is child，function2

因为虽然实际上这个指针指向的是Child类的对象，但编译器无法知道这一事实，它只能按照调用Parent类的函数来理解并编译，所以我们看到了第一行的结果。

第二行中调用了子类的function2，完全是因为virtual 的功能，virtual 实现了动态联编，它可以在运行时判断指针指向的对象，并自动调用相应的函数。

p=&parent;  //这一句，该指针很明显的是指向父类，那么肯定调用的是父类的方法

转载链接：
[1] 虚函数和纯虚函数的区别 https://www.runoob.com/w3cnote/cpp-virtual-function.html
[2] C++中virtual（虚函数）的用法 https://www.cnblogs.com/weiyouqing/p/7544988.html

1、虚函数
虚函数是基类中使用关键字virtual声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

#include<iostream>
using namespace std;

class Shape
{
public:
    virtual void doing()
    {
        cout << "Parent class" << endl;
    }   
};
class Child1: public Shape
{
public:
    void doing()
    {
        cout << "Child1 class" << endl;
    }   
};
class Child2: public Shape
{
public:
    void doing()
    {
        cout << "Child2 class" << endl;
    }   
};
int main()
{
    Shape *shape;
    Child1 c1;
    Child2 c2;

    shape = &c1;
    shape->doing();

    shape = &c2;
    shape->doing();

    return 0;
}

上面代码被运行时，结果

Child1 class
Child2 class

2、纯虚函数
纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。

class Shape
{
public:
    virtual int doing() = 0；
};

= 0, 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

3、用法

虚函数只能借助于指针或者引用来达到多态的效果。
定义一个函数为虚函数，不代表函数为不被实现函数，而是为了允许用基类的指针来调用子类的这个函数。
定义一个纯虚函数代表这个函数没有被实现。
定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承基类的派生类必须实现这个函数。

使用情形
当定义动物作为一个基类的时候，如果想规范派生类动物的特征时，使用纯虚函数。

#include<iostream>
using namespace std;

class Animal
{
public:
    virtual void feature() = 0;
};
class Dog: public Animal
{
public:
    void feature()
    {
        cout << "狗的特征" << endl;
    }
};
class Cat: public Animal
{
public:
    void feature()
    {
        cout << "猫的特征" << endl;
    }
};
class Bear: public Animal
{
public:
    void feature()
    {
        cout << "熊的特征" << endl;
    }
};
int main()
{
    Animal *_feature[3];
    _feature[0] = new Dog;
    _feature[1] = new Cat;
    _feature[2] = new Bear;

    for(int i = 0; i < 3; i++){
        _feature[i]->feature();
    }
    return 0;
}

上面代码被运行时，结果

狗的特征
猫的特征
熊的特征

虚函数和纯虚函数的区别

class A  
{  
public:  
    virtual void foo()  //定义父类的成员函数为虚函数
    {  
        cout<<"A::foo() is called"<<endl;  
    }  
};  
class B:public A  
{  
public:  
    void foo()  //子类中可以不写 virtual关键字， 重定义父类的成员函数
    {  
        cout<<"B::foo() is called"<<endl;  
    }  
};  
int main(void)  
{   
    A *a = new B;   //A *a = new B();  两者均可  new结果是返回B类型的指针 即 父类的指针指向子类的 形成多态
    a->foo();   // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!  
    return 0;  
}