Wat is een overdracht per referentie?

Doorgeven op referentie (pass by reference) is een mechanisme waarbij een functie het adres (referentie) krijgt van een geheugenruimte waar de gegevens van het argument worden opgeslagen. Als resultaat worden alle wijzigingen die binnen de functie aan de variabele worden aangebracht, weerspiegeld op de oorspronkelijke variabele buiten de functie.

Belangrijkste kenmerken:

• Het adres van het geheugen wordt doorgegeven, niet een kopie van de waarde.
• De functie werkt direct met de originele gegevens.
• Wijzigingen binnen de functie blijven na afloop ervan bestaan.
• Het is toepasbaar op objecten, arrays en andere referentietypen in veel programmeertalen.
• In sommige talen (bijvoorbeeld C++) kunnen primitieve types expliciet per referentie worden doorgegeven met behulp van pointers of referenties.

Voorbeeldcode in Python:

# Doorgeven van een lijst (referentietype)
def modify_list(my_list):
    my_list.append(4) # Wijziging aan de originele lijst

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

# Doorgeven van een nummer (primitief type - doorgeven per waarde in Python)
def modify_number(my_number):
    my_number += 1 # Een lokale kopie wordt gemaakt en gewijzigd

value = 5
modify_number(value)
print(value) # Toont 5 - de originele waarde is niet veranderd

Voorbeeldcode in C++:

#include <iostream>

// Doorgeven per referentie
void modify_value_ref(int &val) {
    val += 10; // Wijziging aan de originele variabele
}

// Doorgeven per waarde (ter vergelijking)
void modify_value_copy(int val) {
    val += 10; // Wijziging aan de lokale kopie
}

int main() {
    int a = 5;
    modify_value_ref(a);
    std::cout << "Na referentie: " << a << std::endl; // Toont 15

    int b = 5;
    modify_value_copy(b);
    std::cout << "Na kopie: " << b << std::endl; // Toont 5

    return 0;
}

Voordelen:

• Efficiënt bij werken met grote hoeveelheden data, omdat geen kopie nodig is.
• Maakt het mogelijk dat functies meerdere waarden kunnen wijzigen via de argumenten.

Nadelen:

• Kan de code minder voorspelbaar maken als de functie argumenten wijzigt zonder dit duidelijk te maken in de naam of documentatie.
• Vereist voorzichtigheid om ongewenste bijwerkingen te voorkomen.