Verwendungsfälle von References

Referenzen sind wie die unbekannten Helden von C++. Sie bieten ein Alias für bestehende Objekte, was verschiedene fortgeschrittene Anwendungsfälle unterstützt und gleichzeitig die Klarheit des Codes gewährleistet. Um das Speichermanagement wirklich zu meistern, ist es wichtig, Referenzen genauso zu lernen und zu respektieren wie Smart Pointer.

Vermeidung unnötiger Kopien für Funktionsparameter

Referenzen werden am häufigsten zur Optimierung von Funktionsparametern verwendet. Wenn Sie ein Argument als Referenz an eine Funktion übergeben, vermeiden Sie den Overhead unnötiger Kopien. Dies ist besonders nützlich beim Umgang mit großen Objekten. Wenn dies im gesamten Programm durchgeführt wird, kann das Übergeben von Argumenten als Referenz zu einer erheblichen Speicher- und Leistungsoptimierung führen.

In diesem Beispiel verketten wir zwei Zeichenfolgen, ohne die Kosten für das Erstellen ihrer Kopien zu verursachen. Stattdessen verwenden wir Referenzen, um direkt mit den ursprünglichen Objekten zu arbeiten, und geben eine neue verkettete Zeichenfolge aus der Funktion zurück. Die Funktion kann wie folgt aufgerufen werden:

Mehrere Werte zurückgeben

Referenzen ermöglichen es Funktionen, mehrere Werte zurückzugeben. Während C++-Funktionen normalerweise einen einzelnen Wert zurückgeben, erlauben es Referenzen, die Referenzparameter zu modifizieren, um mehrere Werte an den Aufrufer zurückzugeben. Betrachten Sie das folgende Beispiel für mehr Klarheit:

main


              123456789101112131415161718192021
            
#include <vector>

// function that returns the minimum and maximum values of a vector of integers
// both the minimum and maximum values will be returned via references
// boolean flag will also be returned from the function body
bool findMinMax(const std::vector<int>& numbers, int& min, int& max) {
    if (numbers.empty())
        return false;  // no values to find
        
    // initializing min and max with the first element of the vector
    min = max = numbers[0]; 
    // the following for loop calculates the minimum and maximum values
    for (int num : numbers) {
        if (num < min)
            min = num; // update min if num is smaller
        if (num > max)
            max = num; // update max if num is larger
    }
    // at this stage, the min and max reference variables will hold relevant values for the caller
    return true; // indicating successful calculation of min and max
}

Im obigen Code nutzen wir die Kraft der Referenzen, um sowohl die minimalen als auch die maximalen Werte eines Vektors an den Aufrufer zurückzugeben. Nachdem die Funktion zurückkehrt, wird der Aufrufer feststellen, dass die beiden Referenzvariablen die korrekten minimalen und maximalen Werte enthalten.

Null-Sicherheit

Referenzen bieten ein Maß an Null-Sicherheit, das bei Zeigern nicht vorhanden ist. Im Gegensatz zu Zeigern können Referenzen nicht auf null gesetzt werden. Das bedeutet, dass eine Referenz bei der Deklaration mit einem gültigen Wert initialisiert werden muss und später nicht explizit auf Null gesetzt werden kann. Zum Beispiel ist der folgende Code nicht erlaubt:

Es gibt jedoch einen wichtigen Vorbehalt zu beachten. Auch wenn Referenzen nicht explizit auf null gesetzt werden können, können sie in der Praxis dennoch „null werden“. Dies kann passieren, wenn Sie versehentlich eine Referenz auf ein Objekt erstellen, das gelöscht wurde oder dessen Gültigkeitsbereich verlassen hat. Betrachten Sie diesen Codeausschnitt:

main


              1234567891011121314
            
#include <iostream>

int main() 
{
    int* ptr = new int(42); // dynamically allocate an integer
    int& ref = *ptr; // create a reference to the allocated integer

    delete ptr; // deallocate the memory

    // at this point, ref has become a null reference because the object it referred to has been deleted.
    // accessing ref now would result in undefined behavior.
    // this line may cause a runtime error.
    std::cout << "Value through ref: " << ref << std::endl; 
}

Im obigen Code haben wir sicher eine Referenz auf einen dynamischen Integer erstellt. Später wird dieser Integer freigegeben, wenn wir den delete-Operator auf den Zeiger aufrufen. Dies führt dazu, dass die Referenz null wird.

Zeiger vs. Referenzen

Zeiger und Referenzen sind beide leistungsstarke Werkzeuge in C++ mit spezifischen Anwendungsfällen. Als einfallsreicher C++-Programmierer ist es wichtig zu wissen, wann man welches verwenden sollte.

Verwenden Sie Zeiger wenn Sie auf verschiedene Objekte zeigen möchten oder wenn Sie die Abwesenheit eines Objekts mit null darstellen möchten. Zeiger sind vielseitig und bieten mehr Flexibilität bei der Verwaltung von dynamischem Speicher.
Referenzen werden typischerweise in Szenarien verwendet, in denen Sie direkt mit vorhandenen Objekten arbeiten möchten, ohne Kopieren oder Neuzuweisung. Wie in den obigen Überschriften erwähnt, verwenden Sie Referenzen, wenn Sie Argumente an Funktionen übergeben müssen, ohne den Overhead des Kopierens, mehrere Werte von Funktionen zurückgeben oder wenn Sie Null-Sicherheit wünschen.

Wir werden später in einem anderen Abschnitt tiefer auf die Unterschiede zwischen Zeigern und Referenzen eingehen.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 4