Variablen über Zeiger ändern

Teil des Abschnitts Logic & Flow der C-Journey von Coddy — Lektion 27 von 63.

Jetzt können Sie die wahre Stärke von Pointern nutzen: die ursprüngliche Variable über eine Funktion zu verändern. Wenn Sie einen Pointer an eine Funktion übergeben, kann die Funktion den Dereferenzierungsoperator verwenden, um den an dieser Speicheradresse gespeicherten Wert zu ändern.

Innerhalb der Funktion dereferenzieren Sie den Zeiger mit dem *-Operator, um auf den Wert der ursprünglichen Variablen zuzugreifen und ihn zu ändern. Diese Technik wird als Pass-by-Reference bezeichnet, da Sie eine Referenz auf den Speicherort der Variablen übergeben.

void doubleValue(int *ptr) {
    *ptr = *ptr * 2;  // Dereferenzieren, um den ursprünglichen Wert zu ändern
}

int main() {
    int x = 5;
    doubleValue(&x);  // Die Adresse von x übergeben
    // x ist jetzt 10!
    return 0;
}

Der Schlüssel liegt in der Verwendung von *ptr auf der linken Seite der Zuweisung, um den Wert an der Speicheradresse zu ändern, die der Pointer hält. Dies ermöglicht es Funktionen, Variablen der aufrufenden Funktion dauerhaft zu ändern, was leistungsstarke Programmiermöglichkeiten eröffnet, die mit pass-by-value schlichtweg nicht möglich sind.

Aufgabe

Einfach

Schreiben Sie ein C-Programm, das die Modifizierung von Variablen durch Pointer demonstriert, indem Sie eine Funktion erstellen, die den Wert einer Ganzzahl verdreifacht.

Ihr Programm sollte:

Eine Funktion namens tripleValue erstellen, die einen Pointer auf eine Ganzzahl als Parameter entgegennimmt
Innerhalb der Funktion tripleValue den Dereferenzierungsoperator verwenden, um den Wert an der Speicheradresse mit 3 zu multiplizieren
Innerhalb der Funktion tripleValue den neuen Wert im Format Value tripled to: [value] ausgeben
In der main-Funktion eine Ganzzahlvariable namens number deklarieren und sie mit dem Wert 8 initialisieren
Den ursprünglichen Wert im Format Original value: [value] ausgeben
Die Funktion tripleValue aufrufen und die Adresse der Variable number mit dem Adressoperator übergeben
Nach dem Funktionsaufruf den endgültigen Wert von number im Format Final value: [value] ausgeben

Ihre Ausgabe sollte zeigen, dass die Funktion die ursprüngliche Variable erfolgreich über den Pointer modifiziert:

Original value: 8
Value tripled to: 24
Final value: 24

Diese Herausforderung demonstriert die Stärke von Pass-by-Reference unter Verwendung von Pointern, wobei die Funktion die ursprüngliche Variable dauerhaft modifizieren kann, indem sie den Pointer dereferenziert und den Wert an diesem Speicherort ändert.

Spickzettel

Sie können die ursprüngliche Variable über eine Funktion mithilfe von Pointern (Zeigern) ändern. Diese Technik wird als Pass-by-Reference bezeichnet, da Sie eine Referenz auf den Speicherort der Variablen übergeben.

Dereferenzieren Sie innerhalb der Funktion den Pointer mit dem *-Operator, um auf den Wert der ursprünglichen Variablen zuzugreifen und diesen zu ändern:

void doubleValue(int *ptr) {
    *ptr = *ptr * 2;  // Dereferenzieren, um den ursprünglichen Wert zu ändern
}

int main() {
    int x = 5;
    doubleValue(&x);  // Die Adresse von x übergeben
    // x ist jetzt 10!
    return 0;
}

Verwenden Sie *ptr auf der linken Seite der Zuweisung, um den Wert an der Speicheradresse zu ändern, die der Pointer hält. Dies ermöglicht es Funktionen, Variablen aus der aufrufenden Funktion dauerhaft zu ändern.

Probier es selbst

#include <stdio.h>

// TODO: Schreiben Sie hier Ihre tripleValue-Funktion

int main() {
    // TODO: Schreiben Sie hier Ihren Code
    // Deklarieren und initialisieren Sie die Variable number
    // Geben Sie den ursprünglichen Wert aus
    // Rufen Sie die tripleValue-Funktion auf
    // Geben Sie den Endwert aus
    
    return 0;
}

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Logic & Flow

2Pointer und Arrays

Array-Namen als Pointer Array-Elemente - Pointer Pointer-Arithmetik Pointer vergleichen Wiederholung: Array-Durchlauf mit Pointern

5Zeiger und Funktionen

Wertübergabe (Pass-by-Value)Zeiger an Funktionen übergebenVariablen über Zeiger ändernEin klassisches Beispiel: Swap Arrays an Funktionen übergeben Zusammenfassung: Zeiger als Funktionsargumente

8Structs und Zeiger

Zeiger auf Structs Der Pfeiloperator (->)Structs per Wert übergeben Übergabe von Struct-Zeigern Dynamische Allokation von Structs Zusammenfassung: Struct ändern - Ptr

11Finale Wiederholungsaufgaben

Wiederholung: Dynamische String-Konkatenation Wiederholung: Array von Structs Wiederholung: Wortfrequenz-Zähler