Overload delle funzioni VS Override in C++

1. Utilizzare il sovraccarico delle funzioni per definire più funzioni con elenchi di parametri diversi in C++
2. Utilizzare la funzione di sostituzione per ridefinire i membri ereditati nella classe derivata in C++

Questo articolo introdurrà le differenze tra l’override delle funzioni rispetto all’override in C++.

Utilizzare il sovraccarico delle funzioni per definire più funzioni con elenchi di parametri diversi in C++

L’overload delle funzioni è la caratteristica del linguaggio C++ per poter avere più funzioni con lo stesso nome, che hanno parametri diversi e si trovano in un ambito. In genere, le funzioni sovraccaricate conducono operazioni molto simili ed è intuitivo definire un singolo nome di funzione per esse ed esporre l’interfaccia con più set di parametri. In questo caso, abbiamo definito una classe denominata Planet con tre funzioni denominate printNumAcu. Tutte queste funzioni hanno parametri diversi e sono differenziate al momento della compilazione. Si noti che le funzioni sovraccaricate devono avere tipi di parametri diversi o un numero diverso di parametri.

#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;
}

Produzione:

9
27
81

Utilizzare la funzione di sostituzione per ridefinire i membri ereditati nella classe derivata in C++

L’override della funzione è la funzionalità associata alle classi derivate e alla loro ereditarietà. Di solito, le classi derivate ereditano tutti i membri della classe base e alcune vengono ridefinite nella classe derivata per implementare una routine personalizzata. Si noti, tuttavia, che la classe base deve specificare le funzioni membro che dovrebbero essere sovrascritte. Queste funzioni membro sono note come funzioni virtuali e includono anche la parola chiave virtual in una definizione. Esiste anche un concetto di funzione virtuale pura, che è un tipo di funzione virtuale che non ha bisogno di essere definita. Le classi che includono o ereditano (senza sovrascrivere) una funzione virtuale pura sono chiamate classi base astratte, che di solito non dovrebbero essere usate per creare oggetti, ma piuttosto derivare altre classi.

#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;
}

Produzione:

Name's Earth 3
Name's Mars 3