C++ Arithmétique des pointeurs

Pointeurs C++

Un pointeur est une adresse représentée par une valeur numérique. Par conséquent, vous pouvez effectuer des opérations arithmétiques sur des pointeurs. Quatre opérations arithmétiques peuvent être effectuées sur des pointeurs : ++, --, +, -.

Supposons queptrsoit un pointeur d'entier pointant vers l'adresse 1000, un entier de 32 bits. Effectuons les opérations arithmétiques suivantes sur ce pointeur :

ptr++

Après l'exécution de ptr++, le pointeur ptr avancera de 4 octets, en pointant vers l'adresse de l'élément entier suivant. Cela est dû au fait que l'arithmétique des pointeurs détermine la distance parcourue en fonction du type et de la taille du pointeur. Dans ce cas, comme il s'agit d'un pointeur d'entier 32 bits, chaque entier occupe 4 octets, donc ptr++ déplacera le pointeur ptr de 4 octets vers l'avant, en pointant vers l'adresse de l'élément entier suivant.

siptrpointe vers un caractère à l'adresse 1000. Lorsque ptr++ est exécuté, la valeur du pointeur ptr augmentera, en pointant vers l'adresse de l'élément caractère suivant. Comme ptr est un pointeur de caractère et que chaque caractère occupe 1 octet, ptr++ augmentera la valeur de ptr de 1, et après exécution ptr pointe vers l'adresse 1001.

Analyse détaillée des opérations arithmétiques sur les pointeurs :

  • Opération d'addition : Vous pouvez effectuer une addition sur des pointeurs. Lorsqu'un entier n est ajouté à un pointeur p, le résultat est que le pointeur p avance de la taille de n éléments. Par exemple, si p est un pointeur vers int et que chaque int occupe 4 octets, alors p + 1 pointera vers l'élément int suivant après celui vers lequel p pointe.

  • Opération de soustraction : Vous pouvez effectuer une soustraction sur des pointeurs. Lorsqu'un entier n est soustrait d'un pointeur p, le résultat est que le pointeur p recule de la taille de n éléments. Par exemple, si p est un pointeur vers int et que chaque int occupe 4 octets, alors p - 1 pointera vers l'élément int précédent celui vers lequel p pointe.

  • Soustraction entre pointeurs : vous pouvez calculer la distance entre deux pointeurs. Lorsqu'un pointeur q est soustrait d'un autre pointeur p, le résultat est le nombre d'éléments entre les deux pointeurs. Par exemple, si p et q sont tous deux des pointeurs vers int et que chaque int occupe 4 octets, alors p - q donnera le nombre d'éléments entre les deux pointeurs.

  • Opération de comparaison entre un pointeur et un entier : vous pouvez comparer un pointeur avec un entier. Vous pouvez utiliser les opérateurs relationnels (tels que <, >, <=, >=) pour comparer des pointeurs avec des entiers. Cette comparaison est généralement utilisée pour déterminer si un pointeur pointe vers un emplacement mémoire valide.

Incrémenter un pointeur

En C++, un pointeur est une variable qui stocke une adresse mémoire. Incrémenter un pointeur signifie faire pointer le pointeur vers l'emplacement mémoire suivant, ce qui signifie généralement pointer vers l'élément de tableau suivant. Incrémenter un pointeur ajuste automatiquement la valeur du pointeur en fonction du type de données vers lequel le pointeur pointe.

Par exemple, si un pointeur pointe vers un élément d'un tableau d'int, alors incrémenter le pointeur le fera pointer vers l'élément int suivant. Voici un exemple simple montrant comment incrémenter un pointeur :

Exemple

#include <iostream> int main() { // Définir un tableau int arr[] = {10, 20, 30, 40, 50}; // Définir un pointeur vers le premier élément du tableau int* ptr = arr; // Afficher l'élément pointé par le pointeur std::cout << "Élément actuellement pointé par le pointeur :" << *ptr << std::endl; // Incrémenter le pointeur ptr++; // Afficher l'élément pointé par le pointeur std::cout << "Élément pointé après incrémentation du pointeur :" << *ptr << std::endl; return 0; }

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

Dans cet exemple, le pointeurptrPointe initialement vers le tableauarrle premier élément. En exécutantptr++, le pointeurptrest incrémenté pour pointer vers l'élément suivant du tableau (c'est-à-dire le deuxième élément).

Lors de l'incrémentation d'un pointeur, la valeur du pointeur augmentera d'un décalage égal à la taille du type de données vers lequel le pointeur pointe. Par exemple, si le pointeur est de typeint*type, chaque incrémentation du pointeur l'augmentera de 4 bytes (en supposantinttype occupe 4 bytes).

Il convient de noter que lors de l'utilisation d'opérations sur les pointeurs, vous devez vous assurer que le pointeur pointe vers une région mémoire valide ; sinon, cela peut provoquer un comportement indéfini ou un plantage du programme. Lorsque vous travaillez sur des tableaux, faites particulièrement attention à éviter que les pointeurs ne dépassent les limites du tableau.

Décrémenter un pointeur

En C++, les pointeurs peuvent non seulement être incrémentés, mais aussi décrémentés. Décrémenter un pointeur signifie faire pointer le pointeur vers l'emplacement mémoire précédent. Comme pour l'incrémentation d'un pointeur, la décrémentation d'un pointeur ajuste également automatiquement la valeur du pointeur en fonction du type de données vers lequel le pointeur pointe.

Voici un exemple simple montrant comment décrémenter un pointeur :

Exemple

#include <iostream> int main() { // Définir un tableau int arr[] = {10, 20, 30, 40, 50}; // Définir un pointeur vers le deuxième élément du tableau int* ptr = &arr[1]; // Afficher l'élément vers lequel le pointeur pointe actuellement std::cout << "Élément actuellement pointé par le pointeur :" << *ptr << std::endl; // Décrémenter le pointeur ptr--; // Afficher l'élément pointé après avoir décrémenté le pointeur std::cout << "Élément pointé après avoir décrémenté le pointeur :" << *ptr << std::endl; return 0; }

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

Dans cet exemple, le pointeurptrPointe initialement vers le tableauarrle deuxième élément. En exécutantptr--, le pointeurptrest décrémenté pour pointer vers le premier élément du tableau.

Lorsqu'on décrémente un pointeur, la valeur du pointeur diminue d'un décalage égal à la taille du type de données vers lequel le pointeur pointe. Par exemple, si le pointeur est de typeint*type, chaque décrémentation du pointeur le diminuera de 4 bytes (en supposantinttype occupe 4 bytes).

Comparaison de pointeurs

En C++, les opérations de comparaison de pointeurs peuvent être utilisées pour déterminer si deux pointeurs pointent vers le même emplacement, si un pointeur pointe vers un emplacement avant ou après l'emplacement d'un autre pointeur, etc. La comparaison de pointeurs comprend principalement les éléments suivants :

  • Comparaison d'égalité (==et!=)
  • Comparaison relationnelle (<, <=, >, >=)

Comparaison d'égalité

La comparaison d'égalité est utilisée pour vérifier si deux pointeurs pointent vers le même emplacement.

Exemple

#include <iostream>

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

    // Vérifier si les pointeurs sont égaux
    if (ptr1 == ptr2) {
        std::cout << ptr1 et ptr2 pointent vers le même emplacement << std::endl;
    } else {
        std::cout << ptr1 et ptr2 pointent vers des emplacements différents << std::endl;
    }

    if (ptr1 != ptr3) {
        std::cout << ptr1 et ptr3 pointent vers des emplacements différents << std::endl;
    } else {
        std::cout << ptr1 et ptr3 pointent vers le même emplacement << std::endl;
    }

    return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

Comparaison relationnelle

La comparaison relationnelle est utilisée pour déterminer si un pointeur pointe vers un emplacement avant ou après l'emplacement d'un autre pointeur. Cela est généralement pertinent lorsque les pointeurs pointent vers des éléments du même tableau.

Exemple

#include <iostream>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int* ptr1 = &arr[1]; // Pointe vers le deuxième élément du tableau
    int* ptr2 = &arr[3]; // Pointe vers le quatrième élément du tableau

    // Compare les positions relatives des pointeurs
    if (ptr1 < ptr2) {
        std::cout << L'élément pointé par ptr1 est avant l'élément pointé par ptr2 << std::endl;
    } else {
        std::cout << L'élément pointé par ptr1 n'est pas avant l'élément pointé par ptr2 << std::endl;
    }

    if (ptr2 > ptr1) {
        std::cout << L'élément pointé par ptr2 est après l'élément pointé par ptr1 << std::endl;
    } else {
        std::cout << L'élément pointé par ptr2 n'est pas après l'élément pointé par ptr1 << std::endl;
    }

    return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

Exemple complet de comparaison de pointeurs :

Exemple

#include <iostream>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int* ptr1 = &arr[1]; // Pointe vers le deuxième élément du tableau
    int* ptr2 = &arr[3]; // Pointe vers le quatrième élément du tableau
    int* ptr3 = &arr[1]; // Pointe vers le deuxième élément du tableau

    // Comparaison d'égalité
    if (ptr1 == ptr3) {
        std::cout << ptr1 et ptr3 pointent vers le même emplacement << std::endl;
    } else {
        std::cout << ptr1 et ptr3 pointent vers des emplacements différents << std::endl;
    }

    if (ptr1 != ptr2) {
        std::cout << ptr1 et ptr2 pointent vers des emplacements différents << std::endl;
    } else {
        std::cout << ptr1 et ptr2 pointent vers le même emplacement << std::endl;
    }

    // Comparaison relationnelle
    if (ptr1 < ptr2) {
        std::cout << L'élément pointé par ptr1 est avant l'élément pointé par ptr2 << std::endl;
    } else {
        std::cout << L'élément pointé par ptr1 n'est pas avant l'élément pointé par ptr2 << std::endl;
    }

    if (ptr2 > ptr1) {
        std::cout << L'élément pointé par ptr2 est après l'élément pointé par ptr1 << std::endl;
    } else {
        std::cout << L'élément pointé par ptr2 n'est pas après l'élément pointé par ptr1 << std::endl;
    }

    return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

Notes

  • Comparaisons dans la même plage de tableau: Comparaisons relationnelles (telles que<, >, <=, >=) entre éléments du même tableau sont pertinentes. Si les pointeurs n’appartiennent pas au même tableau, le résultat de la comparaison relationnelle est indéfini.

  • Le pointeur est nul: Avant de comparer des pointeurs, assurez-vous que les pointeurs ne sont pas des pointeurs nuls (nullptr), sinon cela peut entraîner un comportement indéfini.

Pointeurs C++

autres extensions