Parece que é bom tornar os métodos virtuais privados para separar as interfaces para seguir dois clientes - 1. clientes que instanciam um objeto e chamam o método 2. clientes que derivam da classe e podem querer sobrescrever o método. Simplificando - o primeiro cliente não precisa saber se um método é virtual. Ele chamará o método público não-virtual da classe base que, por sua vez, chamará o método virtual privado. Veja o código abaixo, por exemplo.

Agora, no caso em que o método virtual precisa enviar uma super mensagem ao método virtual correspondente da classe base, como um método Save - que tem que passar por todos os métodos virtuais na cadeia de herança para salvar dados correspondentes a cada nível de derivação - não temos outra opção a não ser usar um método virtual protegido - a menos que haja uma maneira de garantir o salvamento de dados em todos os níveis de derivação sem usar super messaging (não há nenhum que eu saiba).

Eu gostaria de saber se acima do raciocínio correto.

Certifique-se de usar a rolagem para ver o código inteiro.

#include <iostream>
using namespace std;

class A {

    string data;    

protected:

    virtual void SaveData()= 0;

public:

    A():data("Data of A"){}

    void Save(){
        cout << data << endl;        
        SaveData();
    }
};

class B : public A {

    string data;

protected:

    virtual void SaveData() { cout << data << endl;}

public:

    B():data("Data of B") {}

};

class C : public B {

    string data;
protected:

    virtual void SaveData() {
        B::SaveData();
        cout << data << endl;
    }

public:

    C():data("Data of C") {}
};


int main(int argc, const char * argv[])
{
    C c;
    c.Save();

    return 0;
}