C++ Zeigerarithmetik

C++ Zeiger

Ein Zeiger ist eine Adresse, die durch einen numerischen Wert dargestellt wird. Daher können Sie arithmetische Operationen mit Zeigern durchführen. Vier arithmetische Operationen können mit Zeigern durchgeführt werden: ++, --, +, -.

Angenommenptrist ein Integer-Zeiger, der auf die Adresse 1000 zeigt, eine 32-Bit-Ganzzahl. Führen wir die folgenden arithmetischen Operationen mit diesem Zeiger durch:

ptr++

Nach Ausführung von ptr++ wird der Zeiger ptr um 4 Bytes vorwärts bewegt und zeigt auf die Adresse des nächsten Integer-Elements. Dies liegt daran, dass die Zeigerarithmetik die zurückgelegte Strecke basierend auf dem Typ und der Größe des Zeigers bestimmt. In diesem Fall handelt es sich um einen 32-Bit-Integer-Zeiger, jeder Integer belegt 4 Bytes, daher verschiebt ptr++ den Zeiger ptr um 4 Bytes nach vorne und zeigt auf die Adresse des nächsten Integer-Elements.

wennptrauf ein Zeichen an Adresse 1000 zeigt. Wenn ptr++ ausgeführt wird, erhöht sich der Wert des Zeigers ptr und zeigt auf die Adresse des nächsten Zeichenelements. Da ptr ein Zeichenzeiger ist und jedes Zeichen 1 Byte belegt, erhöht ptr++ den Wert von ptr um 1, und nach der Ausführung zeigt ptr auf die Adresse 1001.

Detaillierte Analyse der Zeigerarithmetik-Operationen:

  • Additionsoperation: Sie können Addition mit Zeigern durchführen. Wenn eine Ganzzahl n zu einem Zeiger p addiert wird, bewegt sich der Zeiger p um die Größe von n Elementen vorwärts. Wenn p beispielsweise ein Zeiger auf int ist und jedes int 4 Bytes belegt, dann zeigt p + 1 auf das nächste int-Element nach dem, auf das p zeigt.

  • Subtraktionsoperation: Sie können Subtraktion mit Zeigern durchführen. Wenn eine Ganzzahl n von einem Zeiger p subtrahiert wird, bewegt sich der Zeiger p um die Größe von n Elementen rückwärts. Wenn p beispielsweise ein Zeiger auf int ist und jedes int 4 Bytes belegt, dann zeigt p - 1 auf das vorherige int-Element vor dem, auf das p zeigt.

  • Subtraktion zwischen Zeigern: Sie können den Abstand zwischen zwei Zeigern berechnen. Wenn ein Zeiger q von einem anderen Zeiger p subtrahiert wird, ist das Ergebnis die Anzahl der Elemente zwischen den beiden Zeigern. Wenn beispielsweise p und q beide Zeiger auf int sind und jedes int 4 Bytes belegt, ergibt p - q die Anzahl der Elemente zwischen den beiden Zeigern.

  • Vergleichsoperation zwischen einem Zeiger und einer Ganzzahl: Sie können einen Zeiger mit einer Ganzzahl vergleichen. Sie können relationale Operatoren (wie <, >, <=, >=) verwenden, um Zeiger mit Ganzzahlen zu vergleichen. Dieser Vergleich wird normalerweise verwendet, um festzustellen, ob ein Zeiger auf eine gültige Speicherstelle zeigt.

Einen Zeiger inkrementieren

In C++ ist ein Zeiger eine Variable, die eine Speicheradresse speichert. Einen Zeiger zu inkrementieren bedeutet, den Zeiger auf die nächste Speicherstelle zeigen zu lassen, was normalerweise bedeutet, auf das nächste Array-Element zu zeigen. Beim Inkrementieren eines Zeigers wird der Wert des Zeigers automatisch an den Datentyp angepasst, auf den der Zeiger zeigt.

Wenn beispielsweise ein Zeiger auf ein Element eines int-Arrays zeigt, bewirkt das Inkrementieren des Zeigers, dass er auf das nächste int-Element zeigt. Hier ist ein einfaches Beispiel, das zeigt, wie man einen Zeiger inkrementiert:

Beispiel

#include <iostream> int main() { // Definiere ein Array int arr[] = {10, 20, 30, 40, 50}; // Definiere einen Zeiger auf das erste Element des Arrays int* ptr = arr; // Gib das Element aus, auf das der Zeiger zeigt std::cout << "Element, auf das der Zeiger aktuell zeigt:" << *ptr << std::endl; // Inkrementiere den Zeiger ptr++; // Gib das Element aus, auf das der Zeiger zeigt std::cout << "Element, auf das der Zeiger nach dem Inkrementieren zeigt:" << *ptr << std::endl; return 0; }

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

指针当前指向的元素: 10
递增指针后指向的元素: 20

In diesem Beispiel zeigt der Zeigerptrzunächst auf das Arrayarrdas erste Element. Durch Ausführen vonptr++, der Zeigerptrwird inkrementiert, um auf das nächste Element des Arrays zu zeigen (d. h. das zweite Element).

Beim Inkrementieren eines Zeigers erhöht sich der Wert des Zeigers um einen Offset, der der Größe des Datentyps entspricht, auf den der Zeiger zeigt. Wenn der Zeiger beispielsweise vom Typint*Typ, jedes Inkrement des Zeigers erhöht ihn um 4 Bytes (angenommenintTyp belegt 4 Bytes).

Es ist zu beachten, dass bei Verwendung von Zeigeroperationen sichergestellt werden muss, dass der Zeiger auf einen gültigen Speicherbereich zeigt; andernfalls kann es zu undefiniertem Verhalten oder Programmabstürzen kommen. Bei Operationen auf Arrays ist besonders darauf zu achten, dass Zeiger nicht über die Grenzen des Arrays hinausgehen.

Einen Zeiger dekrementieren

In C++ können Zeiger nicht nur inkrementiert, sondern auch dekrementiert werden. Das Dekrementieren eines Zeigers bedeutet, den Zeiger auf die vorherige Speicherposition zeigen zu lassen. Ähnlich wie beim Inkrementieren eines Zeigers wird auch beim Dekrementieren eines Zeigers der Wert des Zeigers automatisch entsprechend dem Datentyp angepasst, auf den der Zeiger zeigt.

Hier ist ein einfaches Beispiel, das zeigt, wie man einen Zeiger dekrementiert:

Beispiel

#include <iostream> int main() { // Definiere ein Array int arr[] = {10, 20, 30, 40, 50}; // Definiere einen Zeiger auf das zweite Element des Arrays int* ptr = &arr[1]; // Gibt das Element aus, auf das der Zeiger aktuell zeigt std::cout << "Element, auf das der Zeiger aktuell zeigt:" << *ptr << std::endl; // Den Zeiger dekrementieren ptr--; // Gibt das Element aus, auf das nach dem Dekrementieren des Zeigers gezeigt wird std::cout << "Element, auf das nach dem Dekrementieren des Zeigers gezeigt wird:" << *ptr << std::endl; return 0; }

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

指针当前指向的元素: 20
递减指针后指向的元素: 10

In diesem Beispiel zeigt der Zeigerptrzunächst auf das Arrayarrdas zweite Element. Durch Ausführenptr--, der Zeigerptrwird dekrementiert, um auf das erste Element des Arrays zu zeigen.

Beim Dekrementieren eines Zeigers verringert sich der Wert des Zeigers um einen Offset, der der Größe des Datentyps entspricht, auf den der Zeiger zeigt. Wenn der Zeiger beispielsweise vom Typint*Typ ist, verringert jedes Dekrementieren des Zeigers ihn um 4 Bytes (angenommenintTyp belegt 4 Bytes).

Zeigervergleich

In C++ können Zeigervergleichsoperationen verwendet werden, um festzustellen, ob zwei Zeiger auf dieselbe Speicherstelle zeigen, ob ein Zeiger auf eine Speicherstelle vor oder nach der Speicherstelle eines anderen Zeigers zeigt usw. Der Zeigervergleich umfasst hauptsächlich Folgendes:

  • Gleichheitsvergleich (==und!=)
  • Relationaler Vergleich (<, <=, >, >=)

Gleichheitsvergleich

Der Gleichheitsvergleich wird verwendet, um zu prüfen, ob zwei Zeiger auf denselben Speicherort zeigen.

Beispiel

#include <iostream>

int main() {
    int a = 10;
    int b = 20;
    int* ptr1 = &a;
    int* ptr2 = &a;
    int* ptr3 = &b;

    // Prüfen, ob die Zeiger gleich sind
    if (ptr1 == ptr2) {
        std::cout << ptr1 und ptr2 zeigen auf denselben Speicherort << std::endl;
    } else {
        std::cout << ptr1 und ptr2 zeigen auf unterschiedliche Speicherorte << std::endl;
    }

    if (ptr1 != ptr3) {
        std::cout << ptr1 und ptr3 zeigen auf unterschiedliche Speicherorte << std::endl;
    } else {
        std::cout << ptr1 und ptr3 zeigen auf denselben Speicherort << std::endl;
    }

    return 0;
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

ptr1 和 ptr2 指向相同的位置
ptr1 和 ptr3 指向不同的位置

Relationaler Vergleich

Relationale Vergleiche werden verwendet, um zu bestimmen, ob ein Zeiger auf eine Position vor oder nach der Position eines anderen Zeigers zeigt. Dies ist normalerweise sinnvoll, wenn Zeiger auf Elemente desselben Arrays zeigen.

Beispiel

#include <iostream>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int* ptr1 = &arr[1]; // Zeigt auf das zweite Element des Arrays
    int* ptr2 = &arr[3]; // Zeigt auf das vierte Element des Arrays

    // Relative Positionen der Zeiger vergleichen
    if (ptr1 < ptr2) {
        std::cout << Das Element, auf das ptr1 zeigt, liegt vor dem Element, auf das ptr2 zeigt << std::endl;
    } else {
        std::cout << Das Element, auf das ptr1 zeigt, liegt nicht vor dem Element, auf das ptr2 zeigt << std::endl;
    }

    if (ptr2 > ptr1) {
        std::cout << Das Element, auf das ptr2 zeigt, liegt nach dem Element, auf das ptr1 zeigt << std::endl;
    } else {
        std::cout << Das Element, auf das ptr2 zeigt, liegt nicht nach dem Element, auf das ptr1 zeigt << std::endl;
    }

    return 0;
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

ptr1 指向的元素在 ptr2 指向的元素之前
ptr2 指向的元素在 ptr1 指向的元素之后

Vollständiges Beispiel für einen Zeigervergleich:

Beispiel

#include <iostream>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int* ptr1 = &arr[1]; // Zeigt auf das zweite Element des Arrays
    int* ptr2 = &arr[3]; // Zeigt auf das vierte Element des Arrays
    int* ptr3 = &arr[1]; // Zeigt auf das zweite Element des Arrays

    // Gleichheitsvergleich
    if (ptr1 == ptr3) {
        std::cout << ptr1 und ptr3 zeigen auf denselben Speicherort << std::endl;
    } else {
        std::cout << ptr1 und ptr3 zeigen auf unterschiedliche Speicherorte << std::endl;
    }

    if (ptr1 != ptr2) {
        std::cout << ptr1 und ptr2 zeigen auf unterschiedliche Speicherorte << std::endl;
    } else {
        std::cout << ptr1 und ptr2 zeigen auf denselben Speicherort << std::endl;
    }

    // Relationaler Vergleich
    if (ptr1 < ptr2) {
        std::cout << Das Element, auf das ptr1 zeigt, liegt vor dem Element, auf das ptr2 zeigt << std::endl;
    } else {
        std::cout << Das Element, auf das ptr1 zeigt, liegt nicht vor dem Element, auf das ptr2 zeigt << std::endl;
    }

    if (ptr2 > ptr1) {
        std::cout << Das Element, auf das ptr2 zeigt, liegt nach dem Element, auf das ptr1 zeigt << std::endl;
    } else {
        std::cout << Das Element, auf das ptr2 zeigt, liegt nicht nach dem Element, auf das ptr1 zeigt << std::endl;
    }

    return 0;
}

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

ptr1 和 ptr3 指向相同的位置
ptr1 和 ptr2 指向不同的位置
ptr1 指向的元素在 ptr2 指向的元素之前
ptr2 指向的元素在 ptr1 指向的元素之后

Hinweise

  • Vergleiche innerhalb desselben Arraybereichs: Relationale Vergleiche (wie z. B.<, >, <=, >=) zwischen Elementen desselben Arrays sind sinnvoll. Wenn die Zeiger nicht zum selben Array gehören, ist das Ergebnis des relationalen Vergleichs undefiniert.

  • Zeiger ist null: Bevor Sie Zeiger vergleichen, stellen Sie sicher, dass die Zeiger keine Nullzeiger sind (nullptr), andernfalls kann es zu undefiniertem Verhalten führen.

C++ Zeiger

Weitere Erweiterungen