Zahlen tauschen mit Zeigern in C

Einführung

In der C-Programmierung sind Zeiger (Pointers) leistungsstarke Features, die es uns ermöglichen, Daten zu manipulieren, indem wir direkt auf Speicheradressen zugreifen und diese ändern. Eine häufige Anwendung von Zeigern besteht darin, Werte zwischen zwei Variablen auszutauschen, ohne eine dritte Variable zu verwenden.

In diesem Lab (Praktikum) werden wir lernen, wie man ein C-Programm erstellt, das zwei Zahlen mithilfe von Zeigern tauscht. Diese Technik ist in verschiedenen Programmier-Szenarien grundlegend und zeigt die praktische Anwendung von Zeigern zur Speichermanipulation.

Das Lab wird Sie Schritt für Schritt durch die Erstellung eines Programms, seine Kompilierung und Ausführung führen, um den Wertetausch in Aktion zu sehen.

Grundlagen der Zeiger in C

Bevor wir mit dem Programmieren beginnen, lernen wir zunächst, was Zeiger sind und wie sie in C funktionieren.

Was ist ein Zeiger?

Ein Zeiger ist eine Variable, die die Speicheradresse einer anderen Variable speichert. Zeiger sind in C unerlässlich, da sie einen direkten Zugriff auf den Speicher ermöglichen und eine effizientere Manipulation von Daten erlauben.

Syntax von Zeigern

In C werden Zeiger mit dem Sternchen (*)-Symbol deklariert:

int *ptr;    // Declares a pointer to an integer

Beim Arbeiten mit Zeigern verwenden wir zwei wichtige Operatoren:

Der Adress-Operator (&) – gibt die Speicheradresse einer Variable zurück
Der Dereferenzierungsoperator (*) – greift auf den Wert zu, der an der vom Zeiger gehaltenen Adresse gespeichert ist

Erstellen unserer ersten Datei

Beginnen wir damit, unsere Haupt-C-Datei im Projektverzeichnis zu erstellen. Öffnen Sie die IDE und erstellen Sie eine neue Datei mit dem Namen main.c:

Navigieren Sie im Dateiexplorer (linke Seite) zu /home/labex/project
Klicken Sie mit der rechten Maustaste und wählen Sie "Neue Datei" aus
Benennen Sie die Datei main.c
Fügen Sie der Datei die folgende Grundstruktur hinzu:

#include <stdio.h>

int main() {
    // We will add our code here

    return 0;
}

Dadurch wird ein einfaches C-Programm erstellt, das die Standard-Eingabe/Ausgabe-Bibliothek einbindet und eine Hauptfunktion enthält, die 0 zurückgibt, wenn das Programm erfolgreich abgeschlossen wird.

Erstellen der Struktur des Tauschprogramms

Nachdem wir nun Zeiger (Pointers) verstanden haben, bauen wir unser Tauschprogramm Schritt für Schritt auf.

Deklarieren von Variablen und Zeigern

Wir müssen Folgendes deklarieren:

Zwei Ganzzahlvariablen (a und b), um die Werte zu speichern, die wir tauschen möchten
Zwei Ganzzahlzeiger (ptra und ptrb), um die Adressen von a und b zu speichern
Eine temporäre Variable (temp), um den Tauschvorgang zu unterstützen

Aktualisieren Sie Ihre main.c-Datei mit dem folgenden Code:

#include <stdio.h>

int main() {
    // Declare variables
    int a, b;
    int *ptra, *ptrb;
    int temp;

    // Get input from user
    printf("Enter value for a: ");
    scanf("%d", &a);

    printf("Enter value for b: ");
    scanf("%d", &b);

    // Display original values
    printf("\nOriginal values:\n");
    printf("a = %d\n", a);
    printf("b = %d\n", b);

    // We will add more code here in the next step

    return 0;
}

Analyse des Codes

Lassen Sie uns analysieren, was wir bisher getan haben:

Wir haben zwei Ganzzahlen a und b deklariert, die die Werte speichern werden, die wir tauschen möchten
Wir haben zwei Ganzzahlzeiger ptra und ptrb deklariert, die die Speicheradressen von a und b speichern werden
Wir haben eine temporäre Ganzzahl temp deklariert, die uns beim Tauschvorgang helfen wird
Wir haben Code hinzugefügt, um den Benutzer aufzufordern, Werte für a und b einzugeben
Wir haben Code hinzugefügt, um die ursprünglichen Werte von a und b anzuzeigen

Beachten Sie, dass wir in der scanf-Funktion den Adress-Operator (&) verwenden, um der Funktion mitzuteilen, wo die Eingabewerte im Speicher gespeichert werden sollen.

Implementierung der Tauschlogik

Jetzt implementieren wir die eigentliche Tauschlogik mithilfe von Zeigern (Pointers).

Zuweisen von Adressen an Zeiger

Zunächst müssen wir unsere Zeiger so einrichten, dass sie auf unsere Variablen zeigen, indem wir die Adressen von a und b jeweils an ptra und ptrb zuweisen:

// Assign addresses to pointers
ptra = &a;
ptrb = &b;

Der Tauschalgorithmus mit Zeigern

Der Schlüssel zum Tauschen von Werten mit Zeigern besteht darin, die Werte an den Speicherorten zu manipulieren, nicht nur die Zeiger selbst. So gehen wir vor:

Speichern Sie den Wert von a (zugänglich über *ptra) in der temporären Variable temp
Weisen Sie den Wert von b (zugänglich über *ptrb) an a zu (indem Sie *ptra verwenden)
Weisen Sie den temporären Wert (ursprünglicher Wert von a) an b zu (indem Sie *ptrb verwenden)

Aktualisieren Sie Ihre main.c-Datei, indem Sie den folgenden Code an der in der vorherigen Stufe angegebenen Stelle hinzufügen:

#include <stdio.h>

int main() {
    // Declare variables
    int a, b;
    int *ptra, *ptrb;
    int temp;

    // Get input from user
    printf("Enter value for a: ");
    scanf("%d", &a);

    printf("Enter value for b: ");
    scanf("%d", &b);

    // Display original values
    printf("\nOriginal values:\n");
    printf("a = %d\n", a);
    printf("b = %d\n", b);

    // Assign addresses to pointers
    ptra = &a;
    ptrb = &b;

    // Display memory addresses (optional but helpful for understanding)
    printf("\nMemory addresses:\n");
    printf("Address of a: %p\n", ptra);
    printf("Address of b: %p\n", ptrb);

    // Swap the values using pointers
    temp = *ptra;    // Store value of a in temp
    *ptra = *ptrb;   // Assign value of b to a
    *ptrb = temp;    // Assign original value of a to b

    // Display swapped values
    printf("\nAfter swapping:\n");
    printf("a = %d\n", a);
    printf("b = %d\n", b);

    return 0;
}

Verständnis der Tauschlogik

Lassen Sie uns verstehen, wie der Tausch genau funktioniert:

temp = *ptra; - Der *-Operator dereferenziert den Zeiger und greift auf den Wert am Speicherort zu. Diese Zeile speichert den Wert von a in temp.
*ptra = *ptrb; - Dies weist den Wert von b an den Speicherort von a zu und ändert somit effektiv den Wert von a.
*ptrb = temp; - Dies weist den ursprünglichen Wert von a (gespeichert in temp) an den Speicherort von b zu und vervollständigt den Tausch.

Nach diesen Operationen haben die Variablen a und b ihre Werte ausgetauscht, ohne dass sie direkt modifiziert wurden – wir haben nur die Werte an ihren Speicherorten geändert.

Kompilieren und Testen des Tauschprogramms

Nachdem wir unser Programm fertiggestellt haben, lassen Sie uns es kompilieren und ausführen, um die Ergebnisse zu sehen.

Kompilieren des Programms

Um das Programm zu kompilieren, verwenden wir den GNU C Compiler (gcc). Öffnen Sie ein Terminal in der WebIDE und führen Sie den folgenden Befehl aus:

cd ~/project
gcc main.c -o swap_program

Dieser Befehl kompiliert unsere main.c-Datei und erstellt ein ausführbares Programm namens swap_program.

Ausführen des Programms

Jetzt lassen Sie uns unser Programm ausführen, um zu sehen, ob es die Werte korrekt tauscht:

./swap_program

Sie werden aufgefordert, Werte für a und b einzugeben. Nehmen wir beispielsweise an, wir geben ein:

a = 5
b = 10

Das Programm sollte anzeigen:

Die ursprünglichen Werte: a = 5, b = 10
Die Speicheradressen von a und b
Die getauschten Werte: a = 10, b = 5

Verständnis der Ausgabe

Wenn Sie das Programm ausführen, sehen Sie mehrere Abschnitte der Ausgabe:

Ursprüngliche Werte - Zeigt die Werte vor dem Tausch an
Speicheradressen - Zeigt, wo die Variablen im Speicher gespeichert sind (dies wird sich bei jedem Programmstart ändern)
Nach dem Tausch - Zeigt die Werte nach der Tauschoperation an

Versuchen Sie, das Programm mehrmals mit verschiedenen Eingabewerten auszuführen, um sicherzustellen, dass der Tausch immer funktioniert.

Wie funktioniert es im Hintergrund?

Lassen Sie uns visualisieren, was im Speicher passiert:

Zu Beginn, wenn a = 5 und b = 10, haben sie jeweils ihre eigenen Speicherorte
ptra zeigt auf den Speicherort von a
ptrb zeigt auf den Speicherort von b
Während des Tauschs:
- temp bekommt den Wert an ptra (der 5 ist)
- Der Wert an ptra wird auf den Wert an ptrb geändert (der 10 ist)
- Der Wert an ptrb wird auf temp geändert (der 5 ist)
Nach dem Tausch ist a = 10 und b = 5, was effektiv ihre Werte tauscht

Dies zeigt die Stärke von Zeigern (Pointers) - sie ermöglichen es uns, Werte indirekt zu ändern, indem wir direkt die Speicherorte manipulieren.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in C Zeiger (Pointers) verwendet, um die Werte von zwei Variablen zu tauschen. Die behandelten Schlüsselkonzepte umfassen:

Zeiger (Pointers): Variablen, die die Speicheradressen anderer Variablen speichern
Speicheradressen: Eindeutige Orte im Computer-Speicher, an denen Daten gespeichert werden
Zeigeroperationen:
- Der Adressoperator (&), um die Speicheradresse einer Variablen zu erhalten
- Der Dereferenzierungsoperator (*), um auf den Wert an einer Speicheradresse zuzugreifen
Tauschalgorithmus: Verwenden einer temporären Variable und von Zeigern, um Werte zu tauschen

Diese Technik ist ein grundlegendes Konzept in der C-Programmierung und zeigt die Stärke von Zeigern bei der Speichermanipulation. Sie kann in verschiedenen Programmier-Szenarien angewendet werden, wie z. B. in Sortieralgorithmen, Datenstruktur-Operationen und Funktionsimplementierungen.

Indem Sie gelernt haben, wie man Daten über Speicheradressen manipuliert, haben Sie einen wichtigen Schritt beim Beherrschen der C-Programmierung und der Konzepte des Computer-Speichers gemacht.