Lernen Übergeben von Argumenten als Wert/Zeiger/Referenz

C++ bietet einen einzigartigen Vorteil, indem es die direkte Manipulation des Computerspeichers ermöglicht und dadurch eine größere Flexibilität in unseren Programmen schafft. Im Folgenden werden drei Methoden zur Übergabe von Funktionsargumenten aus Sicht des Speichers betrachtet.

Übergabe durch Wert

Im vorherigen Abschnitt haben wir den Gültigkeitsbereich von Variablen besprochen und festgestellt, dass Variablen, die innerhalb einer Funktion erstellt werden, nur innerhalb dieser Funktion zugänglich sind. Dieses Konzept bleibt auch beim Übergeben von Argumenten an eine Funktion bestehen. Variablen, die in der Funktionssignatur deklariert werden, besitzen einen lokalen Gültigkeitsbereich; sie werden durch Wert übergeben, was bedeutet, dass ihre Werte in die Funktion kopiert und in separaten Variablen gespeichert werden (denken Sie an unser Bibliotheksbuch-Beispiel zur Veranschaulichung).

main.cpp


              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. Erstens verbraucht das Übergeben einer Kopie zusätzlichen Speicher. Zweitens gibt es Situationen, in denen es notwendig ist, die Variable innerhalb einer Funktion zu ändern, ohne eine Rückgabeanweisung zu verwenden. In solchen Fällen ist es geeigneter, die Variable über einen Zeiger zu übergeben.

Das Übergeben einer Variablen per Zeiger als Funktionsargument in C++ bedeutet, die Speicheradresse der Variablen anstelle ihres tatsächlichen Werts zu übergeben.
Die Übergabe per Zeiger erfolgt durch die Verwendung von Zeigern (Operator *) in den Funktionsparametern.

main.cpp


              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. Dadurch kann die Funktion den Wert der ursprünglichen Variablen ändern, ohne zusätzliche Operationen (wie das Dereferenzieren eines Zeigers mit dem Operator *) durchführen zu müssen.

Die Übergabe per Referenz erfolgt durch die Verwendung von Referenzen (Operator &) in den Funktionsparametern. Im Allgemeinen ist die Übergabe per Referenz der Übergabe per Zeiger sehr ähnlich, es gibt jedoch zwei wichtige Unterschiede:

Es ist nicht notwendig, innerhalb der Funktion das Dereferenzieren (*) zu verwenden, wenn per Referenz übergeben wird, um auf die Variable zuzugreifen (dadurch besteht direkter Zugriff auf die entsprechende Variable).
Es ist nicht notwendig, den Adressoperator (&) zu verwenden, um die Referenz der Variablen beim Funktionsaufruf zu übergeben (im Funktionskopf muss jedoch weiterhin der Operator & anstelle von * verwendet werden).

main.cpp


              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;
}

Fazit

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 2

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Awesome!

Completion rate improved to 5

Swipe um das Menü anzuzeigen

Übergabe durch Wert

main.cpp


              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

main.cpp


              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

Es ist nicht notwendig, innerhalb der Funktion das Dereferenzieren (*) zu verwenden, wenn per Referenz übergeben wird, um auf die Variable zuzugreifen (dadurch besteht direkter Zugriff auf die entsprechende Variable).
Es ist nicht notwendig, den Adressoperator (&) zu verwenden, um die Referenz der Variablen beim Funktionsaufruf zu übergeben (im Funktionskopf muss jedoch weiterhin der Operator & anstelle von * verwendet werden).

main.cpp


              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;
}

Fazit

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 2