virtual关键字赋予c++支持多态的能力。当你有一个指向某个类的对象的指针时，例如:

class Animal
{
  public:
    virtual int GetNumberOfLegs() = 0;
};

class Duck : public Animal
{
  public:
     int GetNumberOfLegs() { return 2; }
};

class Horse : public Animal
{
  public:
     int GetNumberOfLegs() { return 4; }
};

void SomeFunction(Animal * pAnimal)
{
  cout << pAnimal->GetNumberOfLegs();
}

在这个(愚蠢的)示例中，GetNumberOfLegs()函数根据所调用对象的类返回适当的数字。

现在，考虑函数“SomeFunction”。它不关心传递给它的是什么类型的animal对象，只要它是从animal派生的。编译器会自动地将任何Animal派生类强制转换为Animal，因为它是一个基类。

如果我们这样做:

Duck d;
SomeFunction(&d);

它会输出'2'。如果我们这样做:

Horse h;
SomeFunction(&h);

它会输出'4'。我们不能这样做:

Animal a;
SomeFunction(&a);

因为它不会编译，因为GetNumberOfLegs()虚函数是纯的，这意味着它必须通过派生类(子类)来实现。

纯虚函数主要用于定义:

A)抽象类

这些是基类，你必须从它们中派生出来，然后实现纯虚函数。

b)接口

这些是“空”类，其中所有的函数都是纯虚的，因此你必须派生然后实现所有的函数。

纯虚函数

试试这段代码

#include <iostream>
using namespace std;
class aClassWithPureVirtualFunction
{

public:

    virtual void sayHellow()=0;

};

class anotherClass:aClassWithPureVirtualFunction
{

public:

    void sayHellow()
    {

        cout<<"hellow World";
    }

};
int main()
{
    //aClassWithPureVirtualFunction virtualObject;
    /*
     This not possible to create object of a class that contain pure virtual function
    */
    anotherClass object;
    object.sayHellow();
}

在类anotherClass中，删除sayhello函数并运行代码。你会得到错误!因为当一个类包含一个纯虚函数时，不能从该类创建对象，并且它是继承的，那么它的派生类必须实现该函数。

虚函数

试试其他代码

#include <iostream>
using namespace std;
class aClassWithPureVirtualFunction
{

public:

    virtual void sayHellow()
    {
        cout<<"from base\n";
    }

};

class anotherClass:public aClassWithPureVirtualFunction
{

public:

    void sayHellow()
    {

        cout<<"from derived \n";
    }

};
int main()
{
    aClassWithPureVirtualFunction *baseObject=new aClassWithPureVirtualFunction;
    baseObject->sayHellow();///call base one

    baseObject=new anotherClass;
    baseObject->sayHellow();////call the derived one!

}

这里sayhello函数在基类中被标记为虚函数。它表示编译器尝试在派生类中搜索函数并实现该函数。如果没有找到，则执行基本的一个。谢谢

I'd like to comment on Wikipedia's definition of virtual, as repeated by several here. [At the time this answer was written,] Wikipedia defined a virtual method as one that can be overridden in subclasses. [Fortunately, Wikipedia has been edited since, and it now explains this correctly.] That is incorrect: any method, not just virtual ones, can be overridden in subclasses. What virtual does is to give you polymorphism, that is, the ability to select at run-time the most-derived override of a method.

考虑下面的代码:

#include <iostream>
using namespace std;

class Base {
public:
    void NonVirtual() {
        cout << "Base NonVirtual called.\n";
    }
    virtual void Virtual() {
        cout << "Base Virtual called.\n";
    }
};
class Derived : public Base {
public:
    void NonVirtual() {
        cout << "Derived NonVirtual called.\n";
    }
    void Virtual() {
        cout << "Derived Virtual called.\n";
    }
};

int main() {
    Base* bBase = new Base();
    Base* bDerived = new Derived();

    bBase->NonVirtual();
    bBase->Virtual();
    bDerived->NonVirtual();
    bDerived->Virtual();
}

这个程序的输出是什么?

Base NonVirtual called.
Base Virtual called.
Base NonVirtual called.
Derived Virtual called.

Derived重写Base的每个方法:不仅是虚方法，而且是非虚方法。

我们看到，当你有一个基类指向派生类的指针(bDerived)时，调用NonVirtual调用基类实现。这是在编译时解析的:编译器看到bDerived是一个Base*，而NonVirtual不是virtual，所以它在类Base上进行解析。

然而，调用Virtual调用派生类实现。由于关键字virtual，方法的选择发生在运行时，而不是编译时。这里在编译时发生的事情是，编译器看到这是一个Base*，并且它正在调用一个虚方法，所以它插入一个对虚表的调用，而不是类Base。此虚表在运行时实例化，因此运行时解析为最派生的覆盖。

我希望这不会让你太困惑。简而言之，任何方法都可以被覆盖，但只有虚方法可以提供多态性，即运行时选择派生最多的覆盖。然而，在实践中，覆盖非虚拟方法被认为是不好的实践，很少被使用，所以很多人(包括撰写维基百科文章的人)认为只有虚拟方法可以被覆盖。

“Virtual”意味着该方法可以在子类中重写，但在基类中有一个可直接调用的实现。“纯虚拟”意味着它是一个没有直接可调用实现的虚拟方法。这样的方法必须在继承层次结构中至少重写一次——如果一个类有任何未实现的虚方法，该类的对象就不能被构造，编译就会失败。

@夸克指出，纯虚拟方法可以有一个实现，但由于纯虚拟方法必须被覆盖，所以不能直接调用默认的实现。下面是一个带默认值的纯虚方法的例子:

#include <cstdio>

class A {
public:
    virtual void Hello() = 0;
};

void A::Hello() {
    printf("A::Hello\n");
}

class B : public A {
public:
    void Hello() {
        printf("B::Hello\n");
        A::Hello();
    }
};

int main() {
    /* Prints:
           B::Hello
           A::Hello
    */
    B b;
    b.Hello();
    return 0;
}

根据注释，编译是否失败是特定于编译器的。至少在GCC 4.3.3中，它不会编译:

class A {
public:
    virtual void Hello() = 0;
};

int main()
{
    A a;
    return 0;
}

输出:

$ g++ -c virt.cpp 
virt.cpp: In function ‘int main()’:
virt.cpp:8: error: cannot declare variable ‘a’ to be of abstract type ‘A’
virt.cpp:1: note:   because the following virtual functions are pure within ‘A’:
virt.cpp:3: note:   virtual void A::Hello()

虚函数或虚方法是一种函数或方法，其行为可以在继承类中被具有相同签名的函数覆盖

这并不是对虚函数的一个很好的解释。因为，即使成员不是虚成员，继承类也可以重写它。你可以自己去看看。

当函数以基类作为参数时，这种差异就会显现出来。当您将继承类作为输入时，该函数将使用被覆盖函数的基类实现。但是，如果该函数是虚函数，则使用派生类中实现的函数。

虚方法可以被派生类覆盖，但需要基类中的实现(将要被覆盖的基类)。

纯虚方法没有基类的实现。它们需要由派生类定义。(所以从技术上讲，覆盖不是正确的术语，因为没有什么可以覆盖)。

当派生类重写基类的方法时，Virtual对应于默认的java行为。

纯虚方法对应于抽象类中的抽象方法的行为。而只包含纯虚方法和常量的类则是接口的cppp -pendant。