Funktionsüberladung

Die Funktionsüberladung in C++ ermöglicht es, mehrere Funktionen mit demselben Namen, aber unterschiedlichen Parametern im selben Gültigkeitsbereich zu definieren. Sie erlaubt es Ihnen, Funktionen zu erstellen, die ähnliche Aufgaben erfüllen, jedoch verschiedene Datentypen oder unterschiedliche Parameteranzahlen verarbeiten können. Die Überladung verbessert die Lesbarkeit, Wiederverwendbarkeit und Flexibilität des Codes.

Warum ist die Funktionsüberladung nützlich?

Parametervariation: Funktionen können so angepasst werden, dass sie verschiedene Datentypen oder eine unterschiedliche Anzahl von Parametern verarbeiten, was eine vielseitigere Nutzung ermöglicht.
Lesbarkeit: Indem Funktionen mit ähnlichen Funktionalitäten denselben Namen tragen, wird der Code intuitiver und leichter verständlich.
Code-Wiederverwendbarkeit: Funktionen können für verschiedene Datentypen oder Parameterkombinationen erneut verwendet werden, was eine effiziente Wiederverwendung des Codes fördert.

Wie überlädt man eine Funktion?

Eine Funktion gilt als Überladung einer anderen Funktion, wenn:

Diese Funktionen haben denselben Namen.
Mindestens eines der folgenden Kriterien ist erfüllt:

Diese Funktionen haben Argumente unterschiedlicher Typen.

main


              1234567891011121314151617181920212223
            
#include <iostream>

// Function with one integer parameter
void processValue(int num) {
    std::cout << "Processing integer: " << num << std::endl;
}

// Overloaded function with one double parameter
void processValue(double num) {
    std::cout << "Processing double: " << num << std::endl;
}

int main() {
    // Function calls with different data types
    int intValue = 5;
    double doubleValue = 3.14;

    // Calls the first version of processValue
    processValue(intValue); 

    // Calls the second version of processValue
    processValue(doubleValue);
}

Diese Funktionen haben die gleichen Argumenttypen, aber diese Argumente haben eine andere Reihenfolge in der Funktionssignatur.

main


              123456789101112131415161718192021222324
            
#include <iostream>

// Overloaded function with a different number of arguments
void processValue(int num, std::string text) {
    std::cout << "Integer and string: " << num << ", " << text << std::endl;
}

// Overloaded function with different arguments order
void processValue(std::string text, int num) {
    std::cout << "String and integer: " << text << ", " << num << std::endl;
}

int main() {
    // Function calls with different data types and numbers of arguments
    
    int intValue = 5;
    std::string stringValue = "Hello";

    // Calls the third version of processValue
    processValue(intValue, stringValue); 

    // Calls the forth version of processValue
    processValue(stringValue, intValue); 
}

Erinnere dich

Um die Funktion zu überladen, müssen sie denselben Namen haben

War alles klar?

Danke für Ihr Feedback!

Abschnitt 4. Kapitel 1