Pointer vergleichen

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

Sie haben gelernt, wie man sich mithilfe von Zeigerarithmetik durch Arrays bewegt. Jetzt werden Sie entdecken, dass Zeiger auch mit denselben Vergleichsoperatoren verglichen werden können, die Sie bei regulären Variablen verwenden: ==, !=, < und >.

Wenn Sie zwei Pointer vergleichen, vergleichen Sie deren Speicheradressen. Dies ist besonders nützlich, wenn beide Pointer auf Elemente innerhalb desselben Arrays zeigen, da es Ihnen ermöglicht, deren relative Positionen im Speicher zu bestimmen.

int numbers[5] = {10, 20, 30, 40, 50};
int *start = numbers;        // Zeigt auf das erste Element
int *end = numbers + 4;      // Zeigt auf das letzte Element

if (start < end) {
    printf("start comes before end in memory");
}

Zeigervergleiche werden in Schleifenbedingungen besonders mächtig. Anstatt eine Zählervariable zu verwenden, können Sie Ihre aktuelle Zeigerposition mit einem Zielzeiger vergleichen, um zu steuern, wann die Schleife stoppen soll. Dies erzeugt eleganten, effizienten Code für das Durchlaufen von Arrays.

Die entscheidende Erkenntnis ist, dass ptr1 < ptr2 Ihnen sagt, dass ptr1 auf ein Element zeigt, das früher im Array erscheint als das Element, auf das ptr2 zeigt. Diese Beziehung macht den Zeigervergleich zu einer natürlichen Wahl für die Steuerung von Schleifen, die Arrays sequenziell verarbeiten.

Aufgabe

Einfach

Schreiben Sie ein C-Programm, das Zeigervergleiche verwendet, um ein Array zu durchlaufen und Elemente innerhalb eines bestimmten Bereichs zu finden. Ihr Programm sollte:

Ein Integer-Array namens scores mit 8 Elementen deklarieren und es mit den Werten {45, 78, 92, 63, 87, 34, 91, 56} initialisieren
Zwei Zeiger auf Integer deklarieren: start_ptr und end_ptr
start_ptr so setzen, dass er auf das erste Element des Arrays zeigt
end_ptr mithilfe von Zeigerarithmetik so setzen, dass er auf das letzte Element des Arrays zeigt
Einen Zeiger namens current_ptr deklarieren und ihn so initialisieren, dass er auf das erste Element zeigt
Eine while-Schleife mit Zeigervergleich (current_ptr <= end_ptr) verwenden, um das Array zu durchlaufen
Innerhalb der Schleife:
- Prüfen, ob der aktuelle Wert zwischen 60 und 90 (einschließlich) liegt
- Wenn der Wert im Bereich liegt, geben Sie "Value [value] is in range" aus
- Wenn der Wert nicht im Bereich liegt, geben Sie "Value [value] is out of range" aus
- Inkrementieren Sie current_ptr, um zum nächsten Element zu gelangen
Nach der Schleife einen Zeigervergleich verwenden, um zu verifizieren, dass current_ptr nun über das Ende des Arrays hinausreicht, indem Sie prüfen, ob current_ptr > end_ptr
Wenn die Bedingung wahr ist, geben Sie "Traversal complete" aus

Ihre Ausgabe sollte die Ergebnisse im folgenden Format anzeigen:

Value 45 is out of range
Value 78 is in range
Value 92 is out of range
Value 63 is in range
Value 87 is in range
Value 34 is out of range
Value 91 is out of range
Value 56 is out of range
Traversal complete

Diese Herausforderung testet Ihr Verständnis von Zeigervergleichsoperatoren in Schleifenbedingungen, die Verwendung von Zeigerarithmetik zum Setzen von Begrenzungszeigern und wie Zeigervergleiche die Array-Durchquerung eleganter steuern können als herkömmliche zählerbasierte Schleifen.

Spickzettel

Pointer können mit relationalen Operatoren verglichen werden: ==, !=, < und >.

Beim Vergleichen von Pointern vergleichen Sie deren Speicheradressen. Dies ist nützlich, um die relativen Positionen von Elementen innerhalb desselben Arrays zu bestimmen.

int numbers[5] = {10, 20, 30, 40, 50};
int *start = numbers;        // Points to first element
int *end = numbers + 4;      // Points to last element

if (start < end) {
    printf("start comes before end in memory");
}

Der Pointer-Vergleich ist besonders leistungsfähig in Schleifenbedingungen, da er es Ihnen ermöglicht, Schleifen durch den Vergleich von Pointer-Positionen zu steuern, anstatt Zählervariablen zu verwenden:

int *current_ptr = numbers;
int *end_ptr = numbers + 4;

while (current_ptr <= end_ptr) {
    // Process current element
    current_ptr++;  // Move to next element
}

Der Ausdruck ptr1 < ptr2 bedeutet, dass ptr1 auf ein Element zeigt, das im Array früher erscheint als das Element, auf das ptr2 zeigt.

Probier es selbst

#include <stdio.h>

int main() {
    // TODO: Schreibe deinen Code unten
    
    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-ArithmetikPointer vergleichenWiederholung: Array-Durchlauf mit Pointern

5Zeiger und Funktionen

Wertübergabe (Pass-by-Value)Zeiger an Funktionen übergeben Variablen ü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