Was ist eine Referenzübertragung?

Übergabe per Referenz (pass by reference) ist ein Mechanismus, bei dem einer Funktion die Adresse (Referenz) eines Speicherbereichs übergeben wird, in dem die Daten des Argumentes gespeichert sind. Dadurch spiegeln sich alle Änderungen, die innerhalb der Funktion an der Variablen vorgenommen werden, in der ursprünglichen Variablen außerhalb wider.

Hauptmerkmale:

• Es wird die Speicheradresse übergeben, nicht eine Kopie des Wertes.
• Die Funktion arbeitet direkt mit den Originaldaten.
• Änderungen innerhalb der Funktion bleiben nach deren Abschluss bestehen.
• Gilt für Objekte, Arrays und andere referenzielle Datentypen in vielen Programmiersprachen.
• In einigen Sprachen (z.B. C++) kann man primitive Typen explizit per Referenz übergeben, indem man Zeiger oder Referenzen verwendet.

Beispielcode in Python:

# Übergabe einer Liste (referenzierter Typ)
def modify_list(my_list):
    my_list.append(4) # Änderung an der Original-Liste

data = [1, 2, 3]
modify_list(data)
print(data) # Gibt [1, 2, 3, 4] aus

# Übergabe einer Zahl (primitiver Typ - Übergabe per Wert in Python)
def modify_number(my_number):
    my_number += 1 # Es wird eine lokale Kopie erstellt, die geändert wird

value = 5
modify_number(value)
print(value) # Gibt 5 aus - der ursprüngliche Wert hat sich nicht geändert

C++ Beispiel:

#include <iostream>

// Übergabe per Referenz
void modify_value_ref(int &val) {
    val += 10; // Änderung an der Original-Variable
}

// Übergabe per Wert (zum Vergleich)
void modify_value_copy(int val) {
    val += 10; // Änderung an der lokalen Kopie
}

int main() {
    int a = 5;
    modify_value_ref(a);
    std::cout << "Nach Referenz: " << a << std::endl; // Gibt Nach Referenz: 15 aus

    int b = 5;
    modify_value_copy(b);
    std::cout << "Nach Kopie: " << b << std::endl; // Gibt Nach Kopie: 5 aus

    return 0;
}

Vorteile:

• Effizient bei der Arbeit mit großen Datenmengen, da keine Kopie erforderlich ist.
• Erlaubt Funktionen, mehrere Werte durch Argumente zu ändern.

Nachteile:

• Kann den Code weniger vorhersagbar machen, wenn die Funktion die Argumente ohne klare Hinweise im Namen oder in der Dokumentation ändert.
• Erfordert Vorsicht, um unerwünschte Nebenwirkungen zu vermeiden.