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

Récemment, j'ai rencontré ce problème que je suis incapable de comprendre par moi-même.

Que signifient vraiment ces trois Expressions ?

*ptr++
*++ptr
++*ptr

J'ai essayé de Ritchie. Mais malheureusement, il a été incapable de suivre ce qu'il a dit au sujet de ces 3 opérations.

Je sais qu'ils sont tous effectués pour incrémenter le pointeur / la valeur pointée. Je peux aussi deviner qu'il peut y avoir beaucoup de choses sur la priorité et l'ordre d'évaluation. Comme on incrémente le pointeur d'abord, puis récupère le contenu de ce pointeur, tout simplement, on récupère le contenu, puis incrémente le pointeur etc etc. Comme vous pouvez le voir, je n'ai pas une compréhension claire de leurs opérations réelles , que je voudrais effacer dès que possible. Mais je suis vraiment perdu quand j'ai la chance de les appliquer dans les programmes. Par exemple:

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

Me donne cette sortie:

ello

Mais mon attente était qu'il imprimerait Hello . Une dernière demande-veuillez me donner des exemples pour chaque expression fonctionne dans un extrait de code donné. Comme la plupart du temps, seul un simple paragraphe de la théorie me survole la tête.

107
demandé sur Jarod42 2013-08-28 11:27:33

10 réponses

Voici une explication détaillée qui, j'espère, sera utile. Commençons par votre programme, car c'est le plus simple à expliquer.

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

La première déclaration:

const char* p = "Hello";

Déclare p comme un pointeur vers char. Quand nous disons " pointeur vers un char", qu'est-ce que cela signifie? Cela signifie que la valeur de p est l'adresse d'un char; p nous dit où en mémoire il y a de l'espace mis de côté pour tenir un char.

L'instruction initialise également p pour pointez sur le premier caractère de la chaîne littérale "Hello". Pour cet exercice, il est important de comprendre que {[26] } ne pointe pas vers la chaîne entière, mais seulement vers le premier caractère, 'H'. Après tout, p est un pointeur vers un char, pas vers la chaîne entière. La valeur de p est l'adresse de la 'H' dans "Hello".

Ensuite, vous configurez une boucle:

while (*p++)

Que signifie la condition de boucle *p++? Trois choses sont à l'œuvre ici qui rendent cela déroutant (à moins jusqu'à ce que la familiarité s'installe):

  1. La priorité des deux opérateurs, postfix ++ et indirection *
  2. la valeur d'une expression d'incrément postfix
  3. l'effet secondaire d'une expression d'incrément postfix

1. Priorité . Un rapide coup d'œil à la table de priorité pour les opérateurs vous indiquera que l'incrément postfix a une priorité plus élevée (16) que la déréférence / indirection (15). Cela signifie que le complexe l'expression *p++ va être regroupées comme: *(p++). C'est-à-dire, la * pièce sera appliqué à la valeur de la p++ partie. Prenons d'abord la partie p++.

2. Valeur d'expression Postfix . La valeur de p++ est la valeur de p avant que l'accroissement. Si vous avez:

int i = 7;
printf ("%d\n", i++);
printf ("%d\n", i);

, La sortie sera:

7
8

Parce que i++ évalue à i avant l'incrément. De même p++ va évaluer au courant valeur de p. Comme nous le savons, la valeur actuelle de p est l'adresse de 'H'.

Le p++ une partie de *p++ a été évalué; c'est la valeur actuelle de p. Ensuite, la partie * se produit. *(current value of p) signifie: accéder à la valeur à l'adresse tenue par p. Nous savons que la valeur à cette adresse est 'H'. Ainsi, l'expression *p++ évalue à 'H'.

Maintenant, attendez une minute, vous êtes en train de dire. Si *p++ est évalué à 'H', pourquoi 'H' ne s'affiche-t-il pas dans le le code ci-dessus? C'est là que les effets secondaires entrent en jeu.

3. Postfix expression effets secondaires . Le postfix ++ a la valeur de l'opérande en cours, mais il a l'effet secondaire {[165] } d'incrémenter cet opérande. Hein? Jetez un oeil à ce code int à nouveau:

int i = 7;
printf ("%d\n", i++);
printf ("%d\n", i);

Comme indiqué précédemment, la sortie sera:

7
8

Lorsque i++ est évaluée dans le premier printf(), il évalue à 7. Mais la norme C garantit qu'à un certain point avant que le second printf() ne commence à s'exécuter, l'effet secondaire de l'opérateur ++ aura eu lieu. C'est-à-dire, avant que le second printf() n'arrive, i aura été incrémenté à la suite de l'opérateur ++ dans le premier printf(). Ceci, en passant, est l'une des rares garanties que la norme donne sur le moment des effets secondaires.

Dans votre code, alors, lorsque l'expression *p++ est évaluée, elle est évaluée à 'H'. Mais au moment où vous arrivez à ce:

printf ("%c", *p)

Cet effet secondaire embêtant s'est produit. p a été incrémenté. Whoa! Il ne pointe plus vers 'H', mais vers un caractère passé 'H': vers le 'e', en d'autres termes. Cela explique votre sortie Cockney:

ello

D'où le refrain des suggestions utiles (et précises) dans les autres réponses: pour imprimer la prononciation reçue "Hello" et non son homologue cockney, vous avez besoin de quelque chose comme

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

Tant pis pour ça. Quid du reste? Vous renseignez-vous sur les significations de ceux-ci:

*ptr++
*++ptr
++*ptr

Nous venons de parler du premier, alors regardons le second: *++ptr.

Nous l'avons vu dans notre première explication que postfix incrément p++ une certaine préséance, un valeur, et effet secondaire. L'incrément de préfixe ++p a le même effet secondaire que son homologue postfix: il incrémente son opérande de 1. Cependant, il a une priorité différente et une priorité différente valeur.

L'incrément de préfixe a une priorité inférieure à celle du postfix; il a la priorité 15. En d'autres termes, il a la même priorité que l'opérateur de déréférence / indirection *. Dans une expression comme

*++ptr

Ce qui importe n'est pas la priorité: les deux opérateurs sont identiques en priorité. Alors associativité entre en jeu. L'incrément de préfixe et l'opérateur d'indirection ont une associativité droite-gauche. En raison de cette associativité, le l'opérande ptr va être regroupé avec l'opérateur le plus à droite ++ avant l'opérateur plus à gauche, *. En d'autres termes, l'expression va être regroupés *(++ptr). Donc, comme avec *ptr++, mais pour une raison différente, ici aussi, le * pièce va être appliqué à la valeur de la ++ptr partie.

Alors, quelle est cette valeur? La valeur du préfixe de l'opérateur d'incrémentation est la valeur de l'opérande après l'incrémentation. Cela en fait une bête très différente de l'opérateur d'incrément postfix. Disons que vous avez:

int i = 7;
printf ("%d\n", ++i);
printf ("%d\n", i);

, La sortie sera:

8
8

... différent de ce que nous avons vu avec l'opérateur postfix. De même, si vous avez:

const char* p = "Hello";
printf ("%c ", *p);    // note space in format string
printf ("%c ", *++p);  // value of ++p is p after the increment
printf ("%c ", *p++);  // value of p++ is p before the increment
printf ("%c ", *p);    // value of p has been incremented as a side effect of p++

, La sortie sera:

H e e l                // good dog

Voyez-vous pourquoi?

Maintenant, nous arrivons à la troisième expression que vous avez posée, ++*ptr. C'est le plus délicat du lot, en fait. Les deux opérateurs ont la même priorité et associativité gauche. Cela signifie l'expression seront regroupés ++(*ptr). La partie ++ sera appliquée à la valeur de la partie *ptr.

Donc, si nous avons:

char q[] = "Hello";
char* p = q;
printf ("%c", ++*p);

La sortie étonnamment égoïste va être:

I

Quoi?! Ok, donc la partie *p va évaluer à 'H'. Ensuite, le ++ entre en jeu, à quel point, il va être appliqué au 'H', pas au pointeur du tout! Que se passe-t-il lorsque vous ajoutez 1 à 'H'? Vous obtenez 1 plus la valeur ASCII de 'H', 72; vous obtenez 73. Représentez cela comme un char, et vous obtenez le char avec la valeur ASCII de 73: 'I'.

Cela prend en charge les trois expressions que vous avez posées dans votre question. Voici un autre, mentionné dans le premier commentaire à votre question:

(*ptr)++ 

Celui-là est intéressant aussi. Si vous avez:

char q[] = "Hello";
char* p = q;
printf ("%c", (*p)++);
printf ("%c\n", *p);

Il vous donnera cette sortie enthousiaste:

HI

Ce qui se passe? Encore une fois, c'est une question de priorité, valeur de l'expression, et effets secondaires. En raison des parenthèses, la partie *p est traitée comme une expression primaire. Les expressions primaires l'emportent sur tout le reste; elles sont évaluées en premier. Et *p, comme vous le savez, évalue 'H'. Le reste de l'expression, la partie ++, est appliquée à cette valeur. Donc, dans ce cas, (*p)++ devient 'H'++.

Quelle est la valeur de 'H'++? Si vous avez dit 'I', vous avez oublié (déjà!) notre discussion de la valeur par rapport à l'effet secondaire avec postfix incrément. Rappelez-vous, 'H'++ évalue à la valeur actuelle de 'H'. Donc, ce premier printf() va imprimer 'H'. Puis, comme un effet secondaire, ce 'H' va être incrémenté à 'I'. La seconde printf() imprime que 'I'. Et vous avez votre salut joyeux.

, mais dans ces deux derniers cas, pourquoi ai-je besoin d'

char q[] = "Hello";
char* p = q;

Pourquoi Je ne peux pas avoir quelque chose comme

/*const*/ char* p = "Hello";
printf ("%c", ++*p);   // attempting to change string literal!

Parce que "Hello" est un littéral de chaîne. Si vous essayez ++*p, vous essayez de changer le 'H' dans la chaîne en 'I', ce qui rend la chaîne entière "Iello". En C, les littéraux de chaîne sont en lecture seule; tenter de les modifier appelle un comportement indéfini. {[131] } est indéfini en anglais aussi, mais ce n'est qu'une coïncidence.

Inversement, vous ne pouvez pas avoir

char p[] = "Hello";
printf ("%c", *++p);  // attempting to modify value of array identifier!

, Pourquoi pas? Parce que dans ce cas, p est un tableau. Un tableau n'est pas une valeur l modifiable; vous ne pouvez pas changer où p points par pré-ou POST-incrément ou décrémenter, parce que le nom du tableau fonctionne comme si c'était un pointeur constant. (Ce n'est pas ce qu'elle est réellement, c'est juste un moyen pratique de le regarder.)

Pour résumer, voici les trois choses que vous avez posées:

*ptr++   // effectively dereferences the pointer, then increments the pointer
*++ptr   // effectively increments the pointer, then dereferences the pointer
++*ptr   // effectively dereferences the pointer, then increments dereferenced value

Et voici un quatrième, tout aussi amusant que les trois autres:

(*ptr)++ // effectively forces a dereference, then increments dereferenced value

Le premier et le second planteront si ptr est en fait un identifiant de tableau. Le troisième et le quatrième planteront si ptr pointe vers un littéral de chaîne.

Voilà. J'espère que c'est tout cristal maintenant. Vous avez été un grand public, et je serai là toute la semaine.

229
répondu verbose 2017-11-10 13:16:16

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.

42
répondu nickie 2013-08-28 07:44:21

*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;
}
13
répondu Jainendra 2018-10-10 03:49:17

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)
7
répondu nouney 2017-11-10 13:17:54

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";).

4
répondu Nobilis 2013-08-28 07:38:21

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++

2
répondu gman 2013-08-28 13:08:20

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

1
répondu Kiran Padwal 2016-02-10 05:36:55
*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é.

0
répondu David R Tribble 2013-09-04 00:05:55

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);
}
0
répondu Achal 2018-03-04 13:24:53
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);
-1
répondu iammosespaulr 2017-11-11 17:23:14