Funktionsüberladung in C++

1. Definieren Sie überladene Funktionen in C++
2. Verwendung von überladene Funktionen mit Vorlagen in C++

In diesem Artikel werden mehrere Methoden zum Verwenden der Funktionsüberladung in C++ veranschaulicht.

Definieren Sie überladene Funktionen in C++

Das Überladen von Funktionen ist als Teil des Ad-hoc-Polymorphismus bekannt, der die Funktionen bereitstellt, die auf Objekte unterschiedlichen Typs angewendet werden können. Diese Funktionen werden nämlich im angegebenen Geltungsbereich mit dem gleichen Namen definiert und sollten sich in der Anzahl oder Art der Argumente unterscheiden. Beachten Sie, dass überladene Funktionen nur eine Reihe verschiedener Funktionen sind, die zur Kompilierzeit aufgelöst werden. Letzteres Merkmal unterscheidet sie vom Laufzeitpolymorphismus, der für virtuelle Funktionen verwendet wird. Der Compiler beobachtet den Typ der Argumente und wählt aus, welche Funktion aufgerufen werden soll.

Überladene Funktionen müssen sich im Parametertyp oder in einer Anzahl von Parametern unterscheiden. Andernfalls tritt der Compilerfehler auf. Auch wenn der Rückgabetyp bei überladenen Funktionen unterschiedlich ist oder Alias-Typen als Argumente verwendet werden, schlägt der Compiler mit einem Fehler fehl. Im folgenden Beispiel haben wir eine Math-Struktur implementiert, die drei statische Funktionen zur Zahlensummierung besitzt. Jede der Funktionen verwendet unterschiedliche Typen von Argumentpaaren und gibt den entsprechenden Typ zurück. Dadurch kann die Math::sum mit Vektorelementen eines anderen Typs aufgerufen werden. Beachten Sie, dass das Schlüsselwort struct eine Klasse in C++ definiert und ihre Member standardmäßig öffentlich sind.

#include <iostream>
#include <vector>

using std::cout;
using std::endl;
using std::string;
using std::vector;

struct Math {
  static auto sum(int x, int y) { return x + y; }

  static auto sum(float x, float y) { return x + y; }

  static auto sum(double x, double y) { return x + y; }
};

int main() {
  vector<int> vec1 = {1, 2, 3, 4, 5};
  vector<float> vec2 = {1.0, 2.0, 3.0, 4.0, 5.0};

  for (const auto &item : vec1) {
    cout << Math::sum(item, item * 2) << "; ";
  }
  cout << endl;

  for (const auto &item : vec2) {
    cout << Math::sum(item, item * 2) << "; ";
  }
  cout << endl;

  return EXIT_SUCCESS;
}

Ausgabe:

3; 6; 9; 12; 15;
3; 6; 9; 12; 15;

Verwendung von überladene Funktionen mit Vorlagen in C++

Vorlagen sind eine Form der generischen Programmierung, die in der Sprache C++ implementiert ist. Es hat ähnliche Funktionen wie das Überladen von Funktionen, da beide zur Kompilierzeit abgeleitet werden. Beachten Sie, dass der folgende Codeausschnitt die Funktion printExponentVec enthält, die die Elemente des generischen Vektors ausgibt. Daher wird es verwendet, um dieselbe Operation für jeden Typ auszuführen, aber wenn wir verschiedene Funktionskörper für verschiedene Typen implementieren möchten, sollte das Überladen von Funktionen verwendet werden.

#include <iostream>
#include <vector>

using std::cout;
using std::endl;
using std::string;
using std::vector;

struct ExponentTwo {
  static auto Calc(int n) { return n * n; }
  static auto Calc(float n) { return n - n * n; }
  static auto Calc(double n) { return n + n * n; }
};

template <typename T>
void printExponentVec(const vector<T> &vec) {
  for (auto &i : vec) {
    cout << ExponentTwo::Calc(i) << "; ";
  }
  cout << endl;
}

int main() {
  vector<int> vec1 = {1, 2, 3, 4, 5};
  vector<float> vec2 = {1.0, 2.0, 3.0, 4.0, 5.0};

  printExponentVec(vec1);
  printExponentVec(vec2);

  return EXIT_SUCCESS;
}

Ausgabe:

1; 4; 9; 16; 25;
0; -2; -6; -12; -20;