Sobrecarga de função VS Substituindo em C++

1. Use a sobrecarga de funções para definir várias funções com listas de parâmetros diferentes em C++
2. Use Substituição de Função para Redefinir Membros Herdados em Classe Derivada em C++

Este artigo apresentará as diferenças entre a sobrecarga de função e a substituição do VS em C++.

Use a sobrecarga de funções para definir várias funções com listas de parâmetros diferentes em C++

A sobrecarga de funções é a característica da linguagem C++ de poder ter múltiplas funções com o mesmo nome, que possuem diferentes parâmetros e estão localizadas em um único escopo. Geralmente, as funções sobrecarregadas conduzem operações muito semelhantes e é apenas intuitivo definir um único nome de função para elas e expor a interface com vários conjuntos de parâmetros. Neste caso, definimos uma classe chamada Planeta com três funções chamadas printNumAcu. Todas essas funções possuem parâmetros diferentes, e eles são diferenciados no momento da compilação. Observe que as funções sobrecarregadas devem ter diferentes tipos de parâmetros ou um número diferente de parâmetros.

#include <iostream>

using std::cin;
using std::cout;
using std::endl;
using std::string;

class Planet {
 private:
  int num{};

 public:
  explicit Planet(int i) : num(i) {}

  void printNumAcu() const { cout << num * num << endl; }

  void printNumAcu(int x) const { cout << num * num * x << endl; }

  void printNumAcu(int x, int y) const { cout << num * num * x * y << endl; }
};

int main() {
  Planet m1(3);

  m1.printNumAcu();
  m1.printNumAcu(3);
  m1.printNumAcu(3, 3);

  return EXIT_SUCCESS;
}

Resultado:

9
27
81

Use Substituição de Função para Redefinir Membros Herdados em Classe Derivada em C++

A substituição de função é o recurso associado às classes derivadas e sua herança. Normalmente, as classes derivadas herdam todos os membros da classe base e alguns são redefinidos na classe derivada para implementar uma rotina personalizada. Observe, porém, que a classe base precisa especificar as funções de membro que devem ser substituídas. Essas funções-membro são conhecidas como funções virtuais e incluem a palavra-chave virtual em uma definição também. Também existe o conceito de função virtual pura, que é um tipo de função virtual que não precisa ser definida. As classes que incluem ou herdam (sem sobrescrever) uma função virtual pura são chamadas de classes básicas abstratas, que geralmente não devem ser usadas para criar objetos, mas sim derivar outras classes.

#include <iostream>

using std::cin;
using std::cout;
using std::endl;
using std::string;

class Planet {
 protected:
  int num{};

 public:
  explicit Planet(int i) : num(i) {}

  virtual void printName() = 0;
};

class Mars : public Planet {
 public:
  explicit Mars(int i) : Planet(i) {}

  void printName() override { cout << "Name's Mars " << num << endl; }
};

class Earth : public Mars {
 public:
  explicit Earth(int i) : Mars(i) {}

  void printName() override { cout << "Name's Earth " << num << endl; }
};

int main() {
  Earth e1(3);

  e1.printName();
  Mars m1 = e1;
  m1.printName();

  return EXIT_SUCCESS;
}

Resultado:

Name's Earth 3
Name's Mars 3