Além disso, estudamos a diferença entre sobrecarga e substituição com a ajuda de um gráfico comparativo.
Gráfico de comparação:
| Base para Comparação | Sobrecarga | Substituindo |
|---|---|---|
| Protótipo | Protótipo difere como número ou tipo de parâmetro pode ser diferente. | Todo o aspecto do protótipo deve ser o mesmo. |
| Palavra chave | Nenhuma palavra-chave aplicada durante a sobrecarga. | A função que deve ser substituída é precedida pela palavra-chave 'virtual', na classe base. |
| Fator distintivo | O número ou o tipo de parâmetro é diferente, o que determina a versão da função que está sendo chamada. | Qual função da classe está sendo chamada pelo ponteiro, é determinada por, endereço de qual objeto da classe é atribuído a esse ponteiro. |
| Definindo Padrão | As funções são redefinidas com o mesmo nome, mas diferentes números e tipos de parâmetros. | A função é definida, precedida por uma palavra-chave 'virtual' na classe principal e redefinida pela classe derivada com a palavra-chave out. |
| Tempo de realização | Tempo de compilação. | Tempo de execução. |
| Construtor / função virtual | Construtores podem ser 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 | A sobrecarga alcança a vinculaçã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 múltiplos métodos”. Isso significa que, se uma função está sobrecarregada, ela contém o mesmo nome de função enquanto é redefinida.
As funções sobrecarregadas diferem no que diz respeito a 'número ou tipo de parâmetro (s)' diferentes, tornando uma função sobrecarregada distinta da outra. Desta forma, o compilador reconhece qual função sobrecarregada está sendo chamada. As funções mais comumente 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; return a; } int load (int x, int y) {// segunda função load () a = x; b = y; return a * b; }}; int main () {sobrecarga O1; O1.load (20); // first load () chamada de função O1.load (20, 40); // segunda chamada de função load ()} Aqui a função load () da sobrecarga da 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 parâmetro inteiro único, 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 Overriding
O polimorfismo alcançado durante o tempo de execução é chamado de "substituição". Isso é feito usando 'herança' e 'funções virtuais'. A função a ser sobrescrita é precedida pela palavra-chave 'virtual' em uma classe base e redefinida em uma classe derivada sem qualquer palavra-chave.
Uma das coisas mais importantes a lembrar em caso de sobrescrever é que o protótipo da função substituída não deve mudar enquanto a classe derivada a redefine. Quando a função sobrescrita recebe uma chamada, o C ++ determina qual versão da função é chamada com base no 'tipo do objeto apontado por um ponteiro' pelo qual a chamada da função é feita.
Implementação de substituição em C ++
base de classe {public: virtual void funct () {// função virtual da classe base cout << "Esta é uma função da classe base ()"; }}; classe derivada1: base pública {public: void funct () {// função virtual da classe base redefinida na classe derivada1 cout << "Esta é uma função da classe derivada1 ()"; }}; classe derivada2: base pública {public: void funct () {// função virtual da classe base redefinida na classe derivada cout funct (); // chama para derivada1 classe funct (). * p = & d2; p-> funct (); // chama para derivada classe funct (). return 0; } Aqui, há uma única classe base que é herdada publicamente por duas classes derivadas. Uma função virtual é definida em uma classe base com uma palavra-chave 'virtual' e é redefinida por ambas as classes derivadas sem nenhuma 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' dá uma chamada para a função funct (), então uma função da classe base é chamada. Em seguida, o endereço do objeto de classe derivada1 'd1' é atribuído ao ponteiro 'p', novamente ele dá a chamada para funct (); aqui a função funct () da classe derived1 é executada. Finalmente, o ponteiro 'p' é atribuído ao objeto da classe derived2. Então 'p' chama a função funct () que executa a função func () da classe derived2.
Se a classe derivada1 / derivada2 não redefiniu funct (), então a funct () da classe base teria sido chamada, pois a função virtual é 'hierárquica'.
Principais diferenças entre sobrecarga e substituição
- 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 a classe diferente à qual pertence, mas com o mesmo tipo e número de parâmetro.
- O nome da função sobrecarregada não precede qualquer palavra-chave, enquanto o nome de uma função substituída precede com o keyord “Virtual” apenas na classe base.
- Qual função sobrecarregada é invocada depende do tipo ou número de parâmetro que é passado para a função. A função substituída de qual classe é invocada depende de qual endereço de objeto da classe é atribuído ao ponteiro, que invocou a função.
- Qual função sobrecarregada deve ser invocada é resolvida durante o tempo de compilação. Qual função substituída a ser invocada é resolvida durante o tempo de execução.
- Construtores podem ser sobrecarregados, mas não podem ser substituídos.
- Os destruidores não podem ser sobrecarregados, mas podem ser substituídos.
- A sobrecarga alcança a vinculação antecipada, já que a função sobrecarregada será invocada é resolvida durante o tempo de compilação. A sobrescrita atinge a ligação tardia, já que a função que é sobreposta será chamada é resolvida durante o tempo de execução.
Semelhanças
- Ambos são aplicados a funções membro de uma classe.
- Polimorfismo é o conceito básico por trás deles.
- O nome da função permanece o mesmo enquanto aplicamos sobrecarga e substituindo as funções.
Conclusão
Sobrecarga e substituição parecem semelhantes, mas este não é o caso. As funções podem ser sobrecarregadas, mas qualquer classe não pode mais redefinir a função sobrecarregada no futuro. Uma função virtual não pode ser sobrecarregada; eles só podem ser substituídos.
