Diferenças entre "private" no Ruby e C++

privado.cpp

//Versão em C++. Repare que quando é chamado o método "publico" numa instância da
//classe filha, ela usa a implementação tanto do método "publico" como o "privado"
//da classe pai.
//Se eu não tivesse redefinido o método "privado" na classe filha, eu teria um erro
//de compilação ao tentar acessar "privado" da classe pai. Da mesma forma, diferente
//de ruby, se eu estiver no escopo certo eu posso chamar um método privado com a
//notação this->privado()

#include <iostream>
using namespace std;

class Algo {
    public:
    void publico() {
        privado();
    }

    private:
    void privado() {
        cout << "Privado!\n";
    }
};

class Balgo : public Algo {
    public:
    void publicoDois() {
        privado();
    }

    private:
    void privado() {
        cout << "Privado da classe filha!\n";
    }
};

int main(int argc, const char *argv[])
{
    Algo a;
    Balgo b;
    a.publico(); //Imprime "Privado!" na tela

    b.publicoDois(); //Imprime "Privado da classe filha!" na tela
    b.publico(); //Imprime "Privado!" na tela
    return 0;
}

privado.rb

#Versão em Ruby. Repare que quando eu redefino "privado" na classe filha, mesmo o
#método "publico" sendo definido na classe pai, passa a usar o método da classe filha.
#Da mesma forma, eu posso chamar "privado" na classe filha (se eu não tivesse re-definido
#o método) sem problemas. Em nenhum caso, porém, eu posso chamar um método privado
#usando a notação "self.privado".

class A
  def publico
    privado
  end

  def privado()
    puts "Privado!"
  end
  private :privado
end

class B < A
  def publico_dois
    privado
  end

  def privado
    puts "Privado da classe filha!"
  end
  private :privado
end

a = A.new
a.publico #Imprime "Privado!" na tela

b = B.new
b.publico_dois #Imprime "Privado da classe filha!" na tela
b.publico #Imprime "Privado da classe filha!" na tela

privado_virtual.cpp

//Versão em C++, usando métodos virtuais. Repare que, agora, quando eu chamo o
//método "publico" numa instância da classe filha, ele usa o método "privado" da classe
//filha, pois o método "privado" foi definido na classe pai como "virtual". PORÉM,
//todas as regras do C++ continuam valendo, ou seja, se nesse caso eu não tivesse
//redefinido o método "privado" na classe filha, eu não conseguiria acessá-lo pelo
//método "publicoDois".

#include <iostream>
using namespace std;

class Algo {
    public:
    void publico() {
        privado();
    }

    private:
    virtual void privado() {
        cout << "Privado!\n";
    }
};

class Balgo : public Algo {
    public:
    void publicoDois() {
        privado();
    }

    private:
    void privado() {
        cout << "Privado da classe filha!\n";
    }
};

int main(int argc, const char *argv[])
{
    Algo a;
    Balgo b;
    a.publico(); //Imprime "Privado!" na tela

    b.publicoDois(); //Imprime "Privado da classe filha!" na tela
    b.publico(); //Imprime "Privado da classe filha!" na tela
    return 0;
}