Überladen von C++-Funktionen

In diesem Tutorial lernen wir das Überladen von Funktionen in C++ anhand von Beispielen kennen.

In C++ können zwei Funktionen denselben Namen haben, wenn die Anzahl und/oder Art der übergebenen Argumente unterschiedlich ist.

Diese Funktionen mit demselben Namen, aber unterschiedlichen Argumenten werden als überladene Funktionen bezeichnet. Zum Beispiel:

// same name different arguments
int test() { }
int test(int a) { }
float test(double a) { }
int test(int a, double b) { }

Hier sind alle 4 Funktionen überladene Funktionen.

Beachten Sie, dass die Rückgabetypen aller dieser 4 Funktionen nicht gleich sind. Überladene Funktionen können unterschiedliche Rückgabetypen haben oder nicht, aber sie müssen unterschiedliche Argumente haben. Zum Beispiel

// Error code
int test(int a) { }
double test(int b){ }

Hier haben beide Funktionen den gleichen Namen, den gleichen Typ und die gleiche Anzahl von Argumenten. Daher gibt der Compiler einen Fehler aus.

Beispiel 1:Überladen mit unterschiedlichen Parametertypen

// Program to compute absolute value
// Works for both int and float

#include <iostream>
using namespace std;

// function with float type parameter
float absolute(float var){
    if (var < 0.0)
        var = -var;
    return var;
}

// function with int type parameter
int absolute(int var) {
     if (var < 0)
         var = -var;
    return var;
}

int main() {
    
    // call function with int type parameter
    cout << "Absolute value of -5 = " << absolute(-5) << endl;

    // call function with float type parameter
    cout << "Absolute value of 5.5 = " << absolute(5.5f) << endl;
    return 0;
}

Ausgabe

Absolute value of -5 = 5
Absolute value of 5.5 = 5.5

In diesem Programm überladen wir den absolute() Funktion. Basierend auf dem Parametertyp, der während des Funktionsaufrufs übergeben wird, wird die entsprechende Funktion aufgerufen.

Beispiel 2:Überladen mit unterschiedlicher Anzahl von Parametern

#include <iostream>
using namespace std;

// function with 2 parameters
void display(int var1, double var2) {
    cout << "Integer number: " << var1;
    cout << " and double number: " << var2 << endl;
}

// function with double type single parameter
void display(double var) {
    cout << "Double number: " << var << endl;
}

// function with int type single parameter
void display(int var) {
    cout << "Integer number: " << var << endl;
}

int main() {

    int a = 5;
    double b = 5.5;

    // call function with int type parameter
    display(a);

    // call function with double type parameter
    display(b);

    // call function with 2 parameters
    display(a, b);

    return 0;
}

Ausgabe

Integer number: 5
Float number: 5.5
Integer number: 5 and double number: 5.5

Hier die display() Die Funktion wird dreimal mit unterschiedlichen Argumenten aufgerufen. Je nach Anzahl und Art der übergebenen Argumente wird der entsprechende display() Funktion wird aufgerufen.

Der Rückgabetyp all dieser Funktionen ist derselbe, aber das muss beim Überladen von Funktionen nicht der Fall sein.

Hinweis: In C++ sind viele Standardbibliotheksfunktionen überladen. Beispiel:sqrt() Funktion kann double annehmen , float , int, usw. als Parameter. Dies ist möglich, weil die sqrt() Funktion ist in C++ überladen.

C++-Funktionen Standardargumente (Parameter) für die C++-Programmierung

C Sprache