Código é poesia

Em um rápido lapso de raciocínio você também chegou a pensar que sobecarga é a mesma coisa que sobrescrita?
Calma, que o @tumaix te explica:

“Sobrecarga é uma coisa, Sobrescrita é outra.

Sobrecarga:
Métodos na mesma classe, com nome igual e argumentos diferentes.

ex., imagina que você tem 4 classes, ‘Jogador’, ‘Mesa’, ‘Baralho’ e
‘Carta’, aonde o Baralho tem que dar cartas a mesa e Jogador. em
Linguagens que não tem sobrecarga, você recisa fazer algo como

Class BaralhoSemSobrecarga{
void daCartasJogador(Jogador j);
void daCartasMesa(Mesa m);
};

só a assinatura. Mas poxa, a ‘Razão de ser’ de ambos os métodos é um
só, que é dar cartas. dai veio a idéia de sobrecarga, que é fazer um
jeito dos métodos existirem com mesmo nome, mas funcionarem de forma
diferente:

Class BaralhoComSobrecarga{
void daCartas(Jogador j);
void daCartas(Mesa m);
}

como os tipos utilizados dentro do método são diferentes, o compilador
constroi o método para ser invocado pelo nome + tipo de parametro
passado ( descoberto pelo comando typeid() ), e só então chama o
método correto. isso é bem bom pra manter a coerência do programa.

Já sobrescrita é quando você cria um método em uma classe:
class Gente{
virtual void falar(){ std::cout << “Eu sou gente” };
}
class Pai : public Gente{
void falar(){ std::cout << “Oi, eu sou o pai”; }
}
class Filho : public Gente{
void falar(){std::cout << “Oi eu sou o filho”; }
}

temos 3 classes, bem pequenas, só pra comparar.

Gente *a = new Gente();
Gente *b = new Pai();
Gente *c = new Filho();

eu criei 3 objetos do tipo ‘Gente’, só que dois dele são subclasses.
isso significa que eu posso fazer
a->falar() e vai sair “Eu sou gente”;
b-> falar() e vai sair “Eu sou o pai”;
c-> falar() e vai sair “Eu sou o filho”.

porque os métodos das classes filho sobrescreveram a classe pai.
isso entretanto, só ocorre quando o método é virtual ( no c++ ) e no
java tem Override.

só que, po, eu tou numa classe ‘Gente’, como é que ele chama o método
da classe ‘Pai’ ou ‘Filho’? o new não tem nada haver com isso, já que
depois que eu dou o new, caio em um ponteiro de ‘Gente’ e gente é
sempre gente.

só que como marquei o método como virtual, ele consegue descobrir qual
o tipo de classe que está associada a memória por uma coisa chamada
vTable ( Virtual Method Table ), que é uma tabela de variação de
métodos que é construida pelo compilador no momento que o programa
está sendo gerado, e essa tabela guarda as informações de classe e
parametros para ser disparado quando usada. ( se usar o comando -fdump
do g++ você consegue ver a tabela gerada ), aqui num exemplo simples
deu o seguinte:

d:
+0: pointer to virtual method table of D (for B1)
+4: value of int_in_b1
+8: pointer to virtual method table of D (for B2)
+12: value of int_in_b2
+16: value of int_in_d

isso me diz que o 0 e o 12 (binários: 000000, 001100 ) são ponteiros
para métodos que estão na verdade em outra classe, e acessando esses
ponteiros, que indicam a posição da memória de execução ( não de dados
) ele consegue saber o código que será executado.

e Isso é sobrescrita =)”

e eu:

“deixa ver se eu entendi:
em sobrecarga temos 2 metodos com o mesmo nome que pertencem a mesma classe e com funções diferentes (certo?)”
- sim!
“em sobrescrita temos metodos com o mesmo nome que pertencem a classes diferentes e que sobrescrevem o método da classe pai com o mesmo nome. se o metdodo da classe filha nao é virtual, qdo chamado ele vai executar o metodo da classe pai?“
- sim!

Valeu @tumaix.

inté.