Funktionsüberladung VS-Überschreibung in C++

1. Verwenden Sie das Überladen von Funktionen, um mehrere Funktionen mit unterschiedlichen Parameterlisten in C++ zu definieren
2. Verwenden Sie das Überschreiben von Funktionen, um geerbte Member in einer abgeleiteten Klasse in C++ neu zu definieren

In diesem Artikel werden die Unterschiede zwischen dem Überladen von Funktionen und dem Überschreiben von VS in C++ vorgestellt.

Verwenden Sie das Überladen von Funktionen, um mehrere Funktionen mit unterschiedlichen Parameterlisten in C++ zu definieren

Das Überladen von Funktionen ist das Merkmal der C++-Sprache, um mehrere Funktionen mit demselben Namen haben zu können, die unterschiedliche Parameter haben und sich in einem Bereich befinden. Im Allgemeinen führen überladene Funktionen sehr ähnliche Operationen durch, und es ist einfach intuitiv, einen einzigen Funktionsnamen für sie zu definieren und die Schnittstelle mit mehreren Parametersätzen bereitzustellen. In diesem Fall haben wir eine Klasse namens Planet mit drei Funktionen namens printNumAcu definiert. Alle diese Funktionen haben unterschiedliche Parameter und werden zur Kompilierzeit differenziert. Beachten Sie, dass überladene Funktionen unterschiedliche Parametertypen oder eine unterschiedliche Anzahl von Parametern haben müssen.

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

Ausgabe:

9
27
81

Verwenden Sie das Überschreiben von Funktionen, um geerbte Member in einer abgeleiteten Klasse in C++ neu zu definieren

Das Überschreiben von Funktionen ist das Feature, das den abgeleiteten Klassen und ihrer Vererbung zugeordnet ist. Normalerweise erben abgeleitete Klassen alle Basisklassenmember, und einige werden in der abgeleiteten Klasse neu definiert, um eine benutzerdefinierte Routine zu implementieren. Beachten Sie jedoch, dass die Basisklasse die Memberfunktionen angeben muss, die überschrieben werden sollen. Diese Memberfunktionen werden als virtuelle Funktionen bezeichnet und enthalten auch das Schlüsselwort virtual in einer Definition. Es gibt auch das Konzept einer rein virtuellen Funktion, bei der es sich um eine Art virtueller Funktion handelt, die nicht definiert werden muss. Klassen, die eine rein virtuelle Funktion enthalten oder erben (ohne sie zu überschreiben), werden als abstrakte Basisklassen bezeichnet, die normalerweise nicht zum Erstellen von Objekten verwendet werden sollten, sondern eher andere Klassen ableiten.

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

Ausgabe:

Name's Earth 3
Name's Mars 3