Contente

• 
  Gráfico de comparação:
• Definição de Sobrecarga
• Implementação de sobrecarga em C ++
• Definição de Substituição
• Implementação de substituição em C ++
• Semelhanças
• Conclusão

Em 'sobrecarregarRed redefinimos as funções sobrecarregadas com o mesmo nome de função, mas com número e tipo de parâmetros diferentes. Em 'substituindo'Protótipo de função substituída é o mesmo em todo o programa, mas a função a ser substituída é precedida pela palavra-chave' virtual 'na classe base e é redefinida pela classe derivada sem nenhuma palavra-chave.

O polimorfismo é uma das características cruciais do POO. Significa simplesmente "usar um nome para vários formulários". O polimorfismo pode ser implementado usando 'sobrecarga de função', 'sobrecarga de operador' e 'função virtual'. Tanto "sobrecarregar" quanto "substituir" implica o conceito de polimorfismo. Aqui, "sobrecarregar" é polimorfismo em tempo de compilação e "substituir" é polimorfismo em tempo de execução. Estudando mais, se falarmos sobre a grande diferença de "sobrecarga" e "substituição".

Além disso, estudamos a diferença entre sobrecarga e substituição com a ajuda de um gráfico de comparação.

1. Gráfico de comparação
2. Definição
3. Principais diferenças
4. Semelhanças
5. Conclusão

Gráfico de comparação:

Base para Comparação	Sobrecarga	Substituindo
Protótipo	O protótipo difere, pois o número ou o tipo de parâmetro pode ser diferente.	Todos os aspectos do protótipo devem ser iguais.
Palavra-chave	Nenhuma palavra-chave aplicada durante a sobrecarga.	A função a ser substituída é precedida pela palavra-chave virtual, na classe base.
Fator de distinção	O número ou tipo de parâmetro difere, o que determina a versão da função que está sendo chamada.	A função de classe que está sendo chamada pelo ponteiro é determinada pelo endereço de qual objeto de classe é atribuído a esse ponteiro.
Definindo padrão	As funções são redefinidas com o mesmo nome, mas com número e tipo diferentes de parâmetro.	A função é definida, precedida por uma palavra-chave virtual na classe principal e redefinida pela classe derivada sem a palavra-chave.
Hora da realização	Tempo de compilação.	Tempo de execução.
Construtor / Função virtual	Os construtores podem estar sobrecarregados.	A função virtual pode ser substituída.
Destruidor	O destruidor não pode ser sobrecarregado.	O destruidor pode ser substituído.
Obrigatório	Sobrecarga atinge ligação antecipada.	Substituir refere-se à ligação tardia.

Definição de Sobrecarga

O polimorfismo em tempo de compilação é chamado de 'sobrecarga'. Como a sobrecarga é gerada a partir de um conceito de polimorfismo, ela fornece "uma interface comum para vários métodos". Isso significa que, se uma função estiver sobrecarregada, ela conterá o mesmo nome da função enquanto for redefinida.

As funções sobrecarregadas diferem em relação a 'número ou tipo de parâmetro' diferente ', faz com que uma função sobrecarregada seja distinta da outra. Dessa maneira, o compilador reconhece qual função sobrecarregada está sendo chamada. As funções mais frequentemente sobrecarregadas são "construtores". "Construtor de cópia" é um tipo de "sobrecarga de construtor".

Implementação de sobrecarga em C ++

sobrecarga de classe {int a, b; public: int load (int x) {// primeira função load () a = x; retornar a; } int load (int x, int y) {// segunda carga () function a = x; b = y; retornar a * b; }}; int main () {sobrecarga O1; O1.load (20); // primeira função da função load () chamada O1.load (20,40); // segunda chamada de função load ()}

Aqui, a função load () da sobrecarga de classe foi sobrecarregada. As duas funções sobrecarregadas da classe podem ser distinguidas de uma maneira que a primeira função load () aceita apenas um único parâmetro inteiro, enquanto a segunda função load () aceita dois parâmetros inteiros. Quando o objeto da sobrecarga de classe chama a função load () com um único parâmetro, a primeira função load () é chamada. Quando o objeto chama a função load () passando dois parâmetros, a segunda função load () é chamada.

Definição de Substituição

O polimorfismo alcançado durante o tempo de execução é chamado de 'substituição'. É realizado usando 'herança' e 'funções virtuais'. A função a ser substituída é precedida pela palavra-chave "virtual" em uma classe base e redefinida em uma classe derivada sem nenhuma palavra-chave.

Uma das coisas mais importantes a serem lembradas em caso de substituição é que o protótipo da função substituída não deve ser alterado enquanto a classe derivada a redefine. Quando uma função substituída recebe uma chamada, o C ++ determina qual versão da função é chamada com base no 'tipo de objeto apontado por um ponteiro' pelo qual a chamada da função é feita.

Implementação de substituição em C ++

classe base {public: virtual void funct () {// função virtual da classe base cout << "Esta é uma classe base funct ()"; }}; classe derivada1: base pública {public: void funct () {// função virtual da classe base redefinida na classe derivada1 cout << "Esta é uma classe derivada1 funct ()"; }}; classe derivada2: base pública {public: void funct () {// função virtual da classe base redefinida na classe derivada2 cout << "Esta é uma classe derivada2 funct ()"; }}; int main () {base * p, b; derivado d1; derivado2 d2; * p = & b; p-> funct (); // chama a classe base funct (). * p = & d1; p-> funct (); // chama a classe derivada1 funct (). * p = & d2; p-> funct (); // chama a classe derivada2 funct (). retornar 0; }

Aqui, há uma única classe base que é herdada publicamente por duas classes derivadas. Uma função virtual é definida em uma classe base com a palavra-chave "virtual" e é redefinida pelas duas classes derivadas sem palavra-chave. Em main (), a classe base cria uma variável de ponteiro 'p' e um objeto 'b'; A classe 'derivada1' cria um objeto d1 e a classe derivada2 cria um objeto d2 '.

Agora, inicialmente o endereço do objeto da classe base 'b' é atribuído ao ponteiro da classe base 'p'. 'P' chama a função funct (), portanto, uma função da classe base é chamada.Em seguida, o endereço do objeto de classe derivada1 'd1' é atribuído ao ponteiro 'p', novamente chama a função (); aqui a função funct () da classe derivada1 é executada. Por fim, o ponteiro 'p' é atribuído ao objeto da classe derivada2. Então 'p' chama a função funct () que executa a função funct () da classe derivada2.

Se a classe derivada1 / derivada2 não redefinisse funct (), a função () da classe base seria chamada, pois a função virtual é "hierárquica".

1. O protótipo de uma função que está sendo sobrecarregada difere devido ao tipo e número de parâmetros que são passados ​​para a função sobrecarregada. Por outro lado, o protótipo da função substituída não muda porque uma função substituída executa uma ação diferente para uma classe diferente à qual pertence, mas com o mesmo tipo e número de parâmetro.
2. O nome da função sobrecarregada não precede nenhuma palavra-chave, enquanto que o nome de uma função substituída precede a palavra-chave “Virtual” apenas na classe base.
3. Qual função sobrecarregada é chamada depende do tipo ou número de parâmetro que é passado para a função. A função substituída da qual a classe é chamada depende de qual endereço de objeto da classe é atribuído ao ponteiro, que invocou a função.
4. Qual função sobrecarregada deve ser chamada é resolvida durante o tempo de compilação. Qual função substituída a ser chamada é resolvida durante o tempo de execução.
5. Os construtores podem estar sobrecarregados, mas não podem ser substituídos.
6. Os destruidores não podem ser sobrecarregados, mas podem ser substituídos.
7. A sobrecarga atinge a ligação antecipada, pois a função sobrecarregada será invocada e resolvida durante o tempo de compilação. A substituição alcança a ligação tardia, pois a função que será substituída será resolvida durante o tempo de execução.

Semelhanças

1. Ambos são aplicados às funções de membro de uma classe.
2. Polimorfismo é o conceito básico por trás de ambos.
3. O nome da função permanece o mesmo enquanto aplicamos sobrecarga e substituição às funções.

Conclusão

Sobrecarregar e substituir parece semelhante, mas não é esse o caso. As funções podem ser sobrecarregadas, mas qualquer classe não pode redefinir ainda mais a função sobrecarregada no futuro. Uma função virtual não pode ser sobrecarregada; eles só podem ser substituídos.