Expressions de pointeur: * ptr++, * ++ptr et ++ * ptr

Supposons que ptr pointe vers le i-ème élément du tableau arr.

1. *ptr++ évalue à arr[i] et ensembles de ptr pour indiquer la (i+1)-ème élément de arr. Il est équivalent à *(ptr++).

2. *++ptr ensembles de ptr pour indiquer la (i+1)-ème élément de arr et donne arr[i+1]. Il est équivalent à *(++ptr).

3. ++*ptr augmente arr[i] de un et évalue à sa valeur augmentée; le pointeur ptr est laissé intact. C'est équivalent à ++(*ptr).

Il y en a aussi un de plus, mais vous auriez besoin de parenthèses pour l'écrire:

1. (*ptr)++ augmente arr[i] de un et évalue à sa valeur avant d'être augmenté; le pointeur ptr est à nouveau laissé intact.

Le reste, vous pouvez comprendre vous-même; il a également été répondu par @Jaguar.

*ptr++ : post increment a pointer ptr

*++ptr : Pre Increment a pointer ptr

++*ptr : preincrement the value at ptr location

Lisez ici à propos des opérateurs pré-Incrémentation et post-incrémentation

Cela donnera Hello en sortie

int main()
{
    const char *p = "Hello";
    while(*p)
         printf("%c",*p++);//Increment the pointer here 
    return 0;
}

La condition dans votre boucle est mauvaise:

while(*p++)
    printf("%c",*p);

Est le même que

while(*p)
{
    p++;
    printf("%c",*p);
}

Et c'est faux, cela devrait être:

while(*p)
{
    printf("%c",*p);
    p++;
} 

*ptr++ est le même que *(ptr++), qui est la suivante:

const char  *ptr = "example";
char  value;

value = *ptr;
++ptr;
printf("%c", value); // will print 'e'

*++ptr est le même que *(++ptr), qui est la suivante:

const char  *ptr = "example";
char  value;

++ptr;
value = *ptr;
printf("%c", value); // will print 'x'

++*ptr est le même que ++(*ptr), qui est la suivante:

const char  *ptr = "example";
char  value;

value = *ptr;
++value;
printf("%c", value); // will print 'f' ('e' + 1)

Vous avez raison sur la priorité, notez que le * a la priorité sur l'incrément de préfixe, mais pas sur l'incrément postfix. Voici comment ces ventilation:

*ptr++ - aller de gauche à droite, déréférencer le pointeur, puis incrémenter la valeur du pointeur (pas ce qu'il pointe, en raison de la priorité de postfix sur dereference)

*++ptr - incrémenter le pointeur, puis le déréférencer, c'est parce que le préfixe et le déréférencement ont la même priorité et sont donc évalués dans ordre de droite à gauche

++*ptr - similaire à ce qui précède en termes de priorité, aller de droite à gauche pour déréférencer le pointeur, puis incrémenter ce que le pointeur pointe. Veuillez noter que dans votre cas, celui-ci conduira à un comportement indéfini car vous essayez de modifier une variable en lecture seule (char* p = "Hello";).

Je vais ajouter ma prise parce que même si les autres réponses sont correctes, je pense qu'il leur manque quelque chose.

 v = *ptr++

Signifie

 temp = ptr;
 ptr  = ptr + 1
 v    = *temp;

Où comme

 *++ptr

Signifie

 ptr = ptr + 1
 v   = *ptr

Il est important de comprendre que post increment (et post Décrémentation) signifie

 temp = ptr       // Temp created here!!!
 ptr  = ptr + 1   // or - 1 if decrement)
 v    = *temp     // Temp destroyed here!!!

Pourquoi est-ce important? Eh bien en C ce n'est pas si important. En C++ bien que ptr puisse être un type complexe comme un itérateur. Par exemple

 for (std::set<int>::iterator it = someSet.begin(); it != someSet.end(); it++)

Dans ce cas, parce que it est un complexe tapez it++ peut-être avoir des effets secondaires en raison de la création temp. Bien sûr, si vous avez de la chance, le compilateur essaiera de jeter du code qui n'est pas nécessaire, mais si le constructeur ou le destructeur de l'itérateur fait quelque chose, alors it++ va montrer ces effets quand il crée temp.

Le court de ce que j'essaie de dire est écrivez ce que vous voulez dire . Si vous voulez dire incrément ptr, puis écrire ++ptr pas ptr++. Si vous voulez dire temp = ptr, ptr += 1, temp alors écrivez ptr++

Postfix et prefix ont une priorité plus élevée que dereference donc

* ptr++ ici post incrémenter ptr, puis pointant vers une nouvelle valeur de ptr

* ++ptr ici pré incrémenter le poing puis pointant vers la nouvelle valeur de ptr

++ * ptr ici d'abord obtenir la valeur de ptr pointant vers et incrémenter ce vlaue

*ptr++    // 1

C'est la même chose que:

    tmp = *ptr;
    ptr++;

, Donc la valeur de l'objet pointé par ptr est récupéré, puis ptr est incrémenté.

*++ptr    // 2

C'est la même chose que:

    ++ptr;
    tmp = *ptr;

Ainsi, le pointeur {[6] } est incrémenté, puis l'objet pointé par ptr est lu.

++*ptr    // 3

C'est la même chose que:

    ++(*ptr);

, de Sorte que l'objet pointé par ptr est incrémenté; ptr lui-même reste inchangé.

Expressions de pointeur: * ptr++, * ++ptr et ++ * ptr:

Note : les pointeurs doivent initialisé et doivent avoir une adresse valide. Parce que dans la RAM en dehors de notre programme (a. out) il y a beaucoup plus de programmes en cours d'exécution simultanément, c'est-à-dire si vous essayez d'accéder à de la mémoire qui n'était pas réservée à votre système D'exploitation par défaut de Segmentation.

Avant d'expliquer cela, considérons un exemple simple ?

#include<stdio.h>
int main()
{
        int num = 300;
        int *ptr;//uninitialized pointer.. must be initialized
        ptr = &num;
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        *ptr = *ptr + 1;//*ptr means value/data on the address.. so here value gets incremented
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        /** observe here that "num" got changed but manually we didn't change, it got modified by pointer **/
        ptr = ptr + 1;//ptr means address.. so here address got incremented
        /**     char pointer gets incremented by 1 bytes
          Integer pointer gets incremented by 4 bytes
         **/
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
}

Analyser la sortie du code ci-dessus, j'espère que vous avez la sortie du code ci-dessus. Une chose est claire dans le code ci-dessus est que le pointeur de nom (ptr) nous parlons de adresse et *ptr signifie que nous parlons abbout valeur/données.

CAS 1 : *ptr++ , *ptr++, *(ptr++) et *(ptr++) :

Mentionné ci-dessus, toutes les 4 syntaxes sont similaires, dans tous les address gets incremented mais comment l'adresse est incrémentée c'est différent.

Note : pour la résolution de toute expression découvrez comment de nombreux opérateurs sont là, dans l'expression, puis de trouver priorités de l'opérateur. I plusieurs opérateurs ayant la même priorité vérifient alors l'ordre d'évolution ou associativité qui peut droite(R) à gauche(L) ot de gauche à droite.

*ptr++ : Ici 2 opérateurs sont là, à savoir de référence( *) et ++(incrémentation). Les deux ont la même priorité, puis vérifiez l'associativité qui est de R à L. donc commence à résoudre de droite à gauche, quels que soient les opérateurs qui viennent en premier.

*ptr++: le premier ++ est venu en résolvant de R À L, donc l'adresse est incrémentée mais son incrément post.

*++ptr : identique au premier ici aussi l'adresse est incrémentée mais son pré incrémentation.

*(ptr++) : ici, il y a 3 opérateurs, parmi lesquels grouping () ayant la plus haute priorité, donc la première adresse ptr++ résolue, c'est-à-dire incrémentée, mais post.

*(++ptr) : même que le cas ci-dessus ici aussi l'adresse obtient incrémenté mais pré incrémenté.

CAS 2 : ++*ptr, ++(*ptr), (*ptr)++ :

Mentionné ci-dessus, toutes les 4 syntaxes sont similaires, dans toutes les valeurs/données sont incrémentées Mais comment la valeur est modifiée est différente.

++*ptr : first * est venu en résolvant de R À L, donc la valeur est modifiée mais son pré incrément.

++(*ptr) : identique au cas ci-dessus, la valeur est modifiée.

(*ptr)++ : Ici, il n'y y a-t-il 3 opérateurs, parmi lesquels grouping () ayant la priorité la plus élevée, Inside () *ptr est là , donc first *ptr est résolu, c'est-à-dire que la valeur est incrémentée mais post.

Note : ++ * ptr et * ptr = * ptr + 1 les deux sont identiques, dans les deux cas la valeur est modifiée. ++ * ptr: seulement 1 instruction (INC) est utilisée, directement la valeur est modifiée en un seul coup. * ptr = * ptr + 1: ici, la première valeur est incrémentée (INC) puis assignée (MOV).

Pour comprendre tout au-dessus de la syntaxe différente de incrémenter sur le pointeur permet de considérer le code simple:

#include<stdio.h>
int main()
{
        int num = 300;
        int *ptr;
        ptr = &num;
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        *ptr++;//address changed(post increment), value remains un-changed
//      *++ptr;//address changed(post increment), value remains un-changed
//      *(ptr)++;//address changed(post increment), value remains un-changed
//      *(++ptr);//address changed(post increment), value remains un-changed

//      ++*ptr;//value changed(pre increment), address remains un-changed
//      (*ptr)++;//value changed(pre increment), address remains un-changed
//      ++(*ptr);//value changed(post increment), address remains un-changed

        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
}

Dans le code ci-dessus, essayez de commenter/annuler les commentaires et d'analyser les résultats.

Pointeurs comme constants : Il n'y a aucun moyen par lequel vous pouvez faire des pointeurs comme constants, peu que je mentionne ici.

1)const int *p, int const *p : Ici value est constante, l'adresse n'est pas constante je.e où p est de pointage ? Une adresse ? Sur cette adresse Quelle est la valeur ? Une certaine valeur à droite ? Cette valeur est constante, vous ne pouvez pas modifier cette valeur mais où le pointeur pointe ? Certains traitent de droit ? Il peut pointer vers une autre adresse aussi.

Pour comprendre cela, considérons le code ci-dessous:

#include<stdio.h>
int main()
{
        int num = 300;
        const int *ptr;//constant value, address is modifible
        ptr = &num;
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        *ptr++;//
//      *++ptr;//possible bcz you are trying to change address which is possible
//      *(ptr)++;//possible
//      *(++ptr);//possible

//      ++*ptr;//not possible bcz you trying to change value which is not allowed
//      (*ptr)++;//not possible
//      ++(*ptr);//not possible

        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
}

Essayez d'analyser la sortie du code ci-dessus

2)int const * p : Il s'appelle '**constant pointe**r ' c'est-à-dire address is constant but value is not constant. Ici, vous n'êtes pas autorisé à changer l'adresse, mais vous pouvez modifier la valeur.

Note : pointeur constant(cas ci-dessus) doit initialiser tout en lui-même déclariung.

Pour comprendre cela permet de vérifier le code simple.

#include<stdio.h>
int main()
{
        int x = 300;
        int* const p;
        p = &x;
        printf("x = %d p =%p and *p = %d\n",num,p,*p);
}

Dans le code ci-dessus, si vous observez qu'il n'y a pas ++*p ou *p++, Vous pouvez penser que c'est un cas simple car nous ne changeons pas d'adresse ou de valeur, mais cela produira une erreur. Pourquoi? Raison que je mentionne dans les commentaires.

#include<stdio.h>
int main()
{
        int x = 300;
        /** constant pointer must initialize while decaring itself **/
        int* const p;//constant pointer i.e its pointing to some address(here its pointing to garbage), it should point to same address(i.e garbage ad
dress only 
        p = &x;// but here what we are doing ? we are changing address. we are making p to point to address of x instead of garbage address.
        printf("x = %d p =%p and *p = %d\n",num,p,*p);
}

Alors, quelle est la Solution de ce problème ?

     int* const p = &x;

Pour en savoir plus sur ce cas, considérons l'exemple ci-dessous.

#include<stdio.h>
int main()
{
        int num = 300;
        int *const ptr = &num;//constant value, address is modifible
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        *ptr++;//not possible
//      *++ptr;//not possible bcz you are trying to change address which is not possible
//      *(ptr)++;//not possible
//      *(++ptr);//not possible

//      ++*ptr;// possible bcz you trying to change value which is allowed
//      (*ptr)++;// possible
//      ++(*ptr);// possible
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
}

3)const int* const p : ici l'adresse et la valeur sont constantes.

Pour comprendre cela, vérifions le code ci-dessous

#include<stdio.h>
int main()
{
        int num = 300;
        const int* const ptr = &num;//constant value,constant address 
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
        *ptr++;//not possible
        ++*ptr;//not possible
        printf(" num = %d ptr = %p and data on ptr : %d \n",num,ptr,*ptr);
}

const char *p = "Hello";   

*p means "Hello"
          ^
          | 
          p

*p++ means "Hello"
             ^
             | 
             p

*++p means "Hello"
            ^
            |     (WHILE THE STATEMENT IS EXECUTED)
            p

*++p means "Hello"
             ^
             |     (AFTER THE STATEMENT IS EXECUTED)
             p

++*p signifie que vous essayez d'augmenter la valeur ASCII de *p qui

   is "Hello"
       ^
       | 
       p

Vous ne pouvez pas incrémenter la valeur car c'est une constante, donc vous obtiendrez une erreur

Quant à votre boucle while, la boucle s'exécute jusqu'à ce que *p++ atteigne la fin de la chaîne où il y a un caractère '\0'(NULL).

Maintenant, puisque *p++ ignore le premier caractère, vous obtiendrez seulement votre sortie à partir du deuxième caractère.

Le code suivant ne sortira pas tout parce que while loop a '\0'

const char *p = "Hello";
    while('\0') 
         printf("%c",*p);

Le code suivant vous donnera la même sortie que le code suivant, c'est-à-dire ello.

const char *p = "Hello";
    while(*++p)
         printf("%c",*p);

...................................

const char *p = "Hello";
    while(*p++)
         printf("%c",*p);