As funções virtuais são usadas para obter polimorfismo em tempo de execução ou, digamos, ligação tardia ou ligação dinâmica. Funções inline são usadas para eficiência. A ideia por trás das funções embutidas é que sempre que a função embutida é chamada, o código da função embutida é inserido ou substituído no ponto da chamada da função embutida em tempo de compilação. As funções embutidas são muito úteis quando pequenas funções são freqüentemente usadas e chamadas muitas vezes em um programa.

Por padrão, todas as funções definidas dentro da classe são implicitamente ou automaticamente consideradas inline, exceto funções virtuais (observe que inline é uma solicitação para o compilador e sua escolha de compilador para fazer inline ou não).

Sempre que a função virtual é chamada usando referência de classe base ou ponteiro, ela não pode ser sequenciada (porque a chamada é resolvida em tempo de execução), mas sempre que chamada usando o objeto (sem referência ou ponteiro) dessa classe, pode ser sequenciada porque o compilador conhece a classe exata de o objeto em tempo de compilação.

#include <iostream>
using namespace std;
class Base
{
public:
    virtual void who()
    {
        cout << "I am Base\n";
    }
};
class Derived: public Base
{
public:
    void who()
    { 
        cout << "I am Derived\n";
    }
};
  
int main()
{
    // note here virtual function who() is called through
    // object of the class (it will be resolved at compile
    // time) so it can be inlined.
    Base b;
    b.who();
  
    // Here virtual function is called through pointer,
    // so it cannot be inlined
    Base *ptr = new Derived();
    ptr->who();
  
    return 0;
}

Referências:
http://www.parashift.com/c++-faq/inline-virtuals.html
Effective C++, de Scott Meyers

Este artigo é uma contribuição de Meet Pravasi . Escreva comentários se encontrar algo incorreto ou se quiser compartilhar mais informações sobre o tópico discutido acima