Zeiger an Funktionen übergeben

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

Nachdem Sie nun die Einschränkungen der Wertübergabe (Pass-by-Value) verstehen, lassen Sie uns untersuchen, wie das Übergeben von Zeigern an Funktionen dieses Problem löst. Anstatt eine Kopie des Wertes einer Variablen zu übergeben, können Sie die Speicheradresse der Variablen an die Funktion übergeben.

Wenn Sie einen Pointer an eine Funktion übergeben, erhält die Funktion Zugriff auf den Speicherort der ursprünglichen Variablen. Das bedeutet, dass die Funktion direkt mit den Originaldaten arbeiten kann und nicht nur mit einer Kopie davon.

void processValue(int *ptr) {
    // ptr enthält die Adresse der ursprünglichen Variable
    // Die Funktion kann nun auf diesen Speicherort zugreifen
}

int main() {
    int x = 10;
    processValue(&x);  // Übergabe der Adresse von x
    return 0;
}

Beachten Sie, wie wir den Adressoperator & beim Aufrufen der Funktion verwenden, um die Adresse der Variablen zu übergeben. Der Funktionsparameter ist als int *ptr deklariert, was darauf hinweist, dass er einen Zeiger auf eine Ganzzahl erwartet. Diese grundlegende Technik eröffnet leistungsstarke Möglichkeiten für Funktionen, mit den Daten Ihres Programms zu interagieren.

Aufgabe

Einfach

Schreiben Sie ein C-Programm, das das Übergeben von Pointern an Funktionen demonstriert. Ihr Programm sollte:

Eine Funktion namens displayValue erstellen, die einen Pointer auf einen Integer als Parameter entgegennimmt
Innerhalb der Funktion displayValue den Dereferenzierungsoperator verwenden, um auf den Wert an der Speicheradresse zuzugreifen und ihn im Format Value at address: [value] auszugeben
In der main-Funktion eine Integer-Variable namens number deklarieren und sie mit dem Wert 42 initialisieren
Den ursprünglichen Wert im Format Original value: [value] ausgeben
Die Funktion displayValue aufrufen und die Adresse der Variable number mit dem Adressoperator übergeben
Nach dem Funktionsaufruf eine Bestätigungsmeldung ausgeben: Function call completed

Ihre Ausgabe sollte zeigen, dass die Funktion die Speicheradresse der ursprünglichen Variable erfolgreich empfängt und darauf zugreift:

Original value: 42
Value at address: 42
Function call completed

Diese Herausforderung führt in das grundlegende Konzept der Übergabe von Pointern an Funktionen ein, wodurch die Funktion auf den Speicherort der ursprünglichen Variable zugreifen kann, anstatt mit einer Kopie ihres Wertes zu arbeiten.

Spickzettel

Beim Übergeben von Zeigern an Funktionen erhält die Funktion Zugriff auf den Speicherort der ursprünglichen Variablen anstatt auf eine Kopie ihres Wertes.

Verwenden Sie den Adressoperator &, um die Adresse einer Variablen an eine Funktion zu übergeben:

void processValue(int *ptr) {
    // ptr holds the address of the original variable
    // The function can now access that memory location
}

int main() {
    int x = 10;
    processValue(&x);  // Pass the address of x
    return 0;
}

Der Funktionsparameter wird als int *ptr deklariert, um anzugeben, dass er einen Zeiger auf eine Ganzzahl (Integer) erwartet.

Probier es selbst

#include <stdio.h>

// TODO: Schreiben Sie hier Ihre displayValue-Funktion

int main() {
    // TODO: Schreiben Sie hier Ihren Code
    // 1. Deklarieren und initialisieren Sie die Variable number
    // 2. Geben Sie den ursprünglichen Wert aus
    // 3. Rufen Sie die displayValue-Funktion auf
    // 4. Geben Sie die Abschlussmeldung 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 ändern Ein 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