Übergabe von Argumenten durch Wert/Pointer/Referenz

C++ bietet einen einzigartigen Vorteil, da es die direkte Manipulation des Computerspeichers ermöglicht, was unseren Programmen eine größere Flexibilität verleiht. Die folgende Diskussion wird drei Methoden zur Übergabe von Funktionsargumenten aus der Perspektive des Speichers untersuchen.

Übergabe nach Wert

Im vorherigen Abschnitt haben wir über Gültigkeitsbereiche von Variablen gesprochen und festgestellt, dass innerhalb einer Funktion erstellte Variablen ausschließlich in dieser Funktion zugänglich sind. Dieses Konzept gilt auch bei der Übergabe von Argumenten an eine Funktion. Variablen, die in der Funktionssignatur deklariert werden, haben eine lokale Reichweite; sie werden nach Wert übergeben, was bedeutet, dass ihre Werte in die Funktion kopiert und in separaten Variablen gespeichert werden (denken Sie an unser Bibliotheksbuch-Beispiel, um dies zu verstehen).

main


              123456789101112131415161718
            
#include <iostream>

// Function that takes an argument by value
void modifyValue(int num) {
  // Modify the parameter (local copy of the argument)
  num = num * 2;
  std::cout << "Inside function: " << num << std::endl;
}

int main() {
    int number = 5;
    std::cout << "Before function call: " << number << std::endl;

    // Call the function and pass 'number' by value
    modifyValue(number);
    // Varibale in the main function remains unchanged
    std::cout << "After function call: " << number << std::endl;
}

Übergabe per Zeiger

Es ist nicht immer sinnvoll, Argumente per Wert zu übergeben. Zum einen verbraucht das Übergeben einer Kopie zusätzlichen Speicher. Zum anderen gibt es Situationen, in denen es notwendig ist, die Variable innerhalb einer Funktion zu ändern, ohne sich auf einen Rückgabewert zu verlassen. In solchen Fällen ist es angemessener, die Variable mithilfe eines Zeigers zu übergeben.

Beim Übergeben einer Variablen per Zeiger in C++ als Funktionsargument wird die Speicheradresse der Variablen statt ihres tatsächlichen Wertes übergeben.
Die Übergabe per Zeiger erfolgt in den Funktionsparametern mithilfe von Zeigern (dem * Operator).

main


              12345678910111213141516171819202122
            
#include <iostream>

// Function that takes an argument using pointer
void modifyValue(int* numPtr)
{
    // Modify the value at the memory address pointed by numPtr
    // '*' is used to extract the value from the address (pointer)
    *numPtr = (*numPtr) * 2;
    std::cout << "Inside function: " << *numPtr << std::endl;
}

int main()
{
    int number = 5;
    std::cout << "Before function call: " << number << std::endl;

    // Call the function and pass the address of 'number' using a pointer
    // '&' is used to get an address of the variable
    modifyValue(&number);
    // 'number' in the main function is modified through the pointer
    std::cout << "After function call: " << number << std::endl;
}

Übergabe per Referenz

In C++ bedeutet die Übergabe per Referenz, dass die Speicheradresse einer Variablen direkt an eine Funktion übergeben wird, was der Funktion ermöglicht, den Originalwert der Variablen ohne zusätzliche Operationen (wie das Dereferenzieren eines Zeigers mittels des * Operators) zu ändern.

Die Übergabe per Referenz erfolgt mittels Referenzen (Operator &) in den Funktionsparametern. Im Allgemeinen ähnelt die Übergabe per Referenz der Übergabe per Zeiger sehr stark, jedoch gibt es zwei wichtige Unterschiede:

Innerhalb der Funktion ist es nicht notwendig, den Dereferenzierungsoperator (*) zu verwenden, um auf die Variable zuzugreifen, wenn diese per Referenz übergeben wird (dadurch haben wir direkten Zugriff auf die entsprechende Variable).
Beim Aufruf der Funktion muss der "Address-of"-Operator (&) nicht verwendet werden, um die Referenz der Variablen als Argument zu übergeben (allerdings muss in der Funktionssignatur weiterhin der & Operator anstelle von * verwendet werden).

main


              1234567891011121314151617181920
            
#include <iostream>

// Function that takes an argument by reference
void modifyValue(int& num)
{
    // Modify the parameter directly (no need for dereferencing)
    num = num * 2;
    std::cout << "Inside function: " << num << std::endl;
}

int main()
{
    int number = 5;
    std::cout << "Before function call: " << number << std::endl;

    // Call the function and pass 'number' by reference
    modifyValue(number);
    // 'number' in the main function is modified directly through the reference
    std::cout << "After function call: " << number << std::endl;
}

Schlussfolgerung

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 2