[C++] Pointeur char*, priorité d'opérateur Fermé

Question

ya tu quelqu'un qui peut m'aider a mettre la ligne dans le while sur plusieurs ligne. J'ai essayé plusieurs chose mais a matin on dirait qui a rien qui marche. :P  voici le code : (pDst et pSrc sont des pointeurs de char)bool bStop = false;while(!bStop || *pSrc){		     bStop = (*pDst++ = *pSrc++) == _T('\0');}*pDst++ = _T('\0');

mamiemando · Answer

Tu peux interrompre une boucle avec l'instruction break :bool bStop = false;while(!bStop){  if(*pSrc) break;  bStop = (*pDst++ = *pSrc++) == _T('\0');}*pDst++ = _T('\0');Bonne chance

Posteur · Answer

Je me suis retrouvé ici par hasard :)  Le sujet est passé depuis pas mal de temps mais je tenais à "hurler" face à la solution donnée.

Je ne pense pas que cette solution soit celle recherchée. Là c'est créer une ligne de plus pour le plaisir d'en créer une de plus. De plus, en algorithmie, les ruptures de boucles dans le bloc n'existent pas (ça correspond à du goto et c'est très mauvais de programmer ainsi).

La ligne qu'il fallait éclater est : bStop = (*pDst++ = *pSrc++) == _T('\0');

(il a bien dit à l'intérieur du while ;-) )


J'ai un peu de mal avec les post et pré incrémentations (je les évite un maximum à l'intérieur d'une expression qui est tout sauf simple -pas de problème dans une instruction d'affichage ou d'affectation toute simple et non combinée-) donc je vais juste donner une ébauche de solution :

*pDst++ = *pSrc++
if(*pDst == _T('\0')) bStop = true; else bStop = false;

L'opérateur ++ (ici en post-incrémentation) a une priorité plus forte que le *. Donc, en utilisant les parenthèses on détermine que :

*pSrc++ c'est le même que *(pSrc++).  
*pDst++ c'est le même que *(pDst++).  

Pourtant, si on se réfère à la définition de la post incrémentation on trouve que l'incrémentation est effectuée après le calcul de l'expression. Par exemple :

int a=5;
printf("%d", a++); // imprime 5 (post incrémentation. "a" vaudra 6 après l'instruction d'affichage).
printf("%d", ++a); // imprime 6 (pré-incrémentation)

Ce qui voudrait dire qu'avant l'affectation, le pointeur est porté sur pSrc et non pas sur pSrc+1. Je me trompe ? (sinon on aurait écrit *++pSrc, qui revient à écrire *(++pSrc) ou *(pSrc+1), ce qui n'est pas notre cas à cause de la post incrémentation.)

Donc ça reviendrait à faire :

*pDst = *pSrc; 
pDst++ ;
pSrc++ ;

(Si je comprends l'intention du code, c'est de copier des valeurs sources vers des espaces mémoire destination, parallèlement... Une copie pure et simple de valeurs de pointeurs. Si ce n'est pas ça c'est que je me suis planté).

mamiemando · Answer

En fait la question était mal posée je viens de capter que ce n'était pas le while qu'il voulait éclater mais ce qu'il y avait dans le bloc while (en tout c'est pour ça qu'à l'époque j'avais mis un break). Pour revenir à ta remarque sur les ruptures de boucles je suis plus ou moins d'accord. Un break en début de boucle agit comme un test supplémentaire dans le while. Les "continue" entreraient également dans ce contexte mais sont équivalent à mettre ce qu'il suit dans un test "if". Bref on est loin du goto et parfois un continue et un break bien placé ne nuisent pas à la lisibilité ou à l'efficacité du code. Dans son cas il a voulu manifestement faire une sorte de strcpy. Voici une manière plus élégante de l'écrire #include #include #include void my_strcpy(char *dst,char *src){ while(*src != '\0'){ *dst = *src; ++src; ++dst; } } int main(){ char *src = "tapir"; char *dst = (char *)calloc((strlen(src)+1),sizeof(char)); my_strcpy(dst,src); printf("src = %s ",src); printf("dst = %s ",dst); free(dst); return 0; } Ce qui donne bien : (mando@polgara) (~) $ gcc -W -Wall plop.c (mando@polgara) (~) $ ./a.out src = tapir dst = tapir La fonction my_strcpy peut aussi s'écrire ainsi void my_strcpy2(char *dst,char *src){ while(*src != '\0') *dst++ = *src++; } ou encore void my_strcpy3(char *dst,char *src){ for(;*src != '\0';++src,++dst) *dst = *src; } Pour revenir aux histoires de pré et post incrémentation, la différence est simple. Une post incrémentation est évaluée après exécution de l'instruction, un pré incrémentation avant. Quand tu incrémentes une variable tu peux écrire indifferemment l'une ou l'autre. for(i=0;i<10;++i) printf("%d ",i); for(i=0;i<10;i++) printf("%d ",i); Par contre l'exemple my_strcpy2 est un exemple clair ou il faut bien distinguer les deux : 1) on récupère la référence de *dst 2) on la passe à l'opérateur = 3) on récupère la référence de *src 4) on rentre dans le code de l'opérateur = : on affecte la valeur de *dst à *src 5) on post incrémente dst 6) on post incrémente src Typiquement si tu préincrémentes tu vas louper le premier caractère de src et de dst. void my_strcpy_bug(char *dst,char *src){ while(*src != '\0') *++dst = *++src; } Dans ce cas là tu vas avoir dst = "\0apir\0" ce qui à l'affichage donnera une chaîne vide. #include #include #include void my_strcpy(char *dst,char *src){ while(*src != '\0') *++dst = *++src; } int main(){ unsigned int i; char *src = "tapir"; char *dst = (char *)calloc((strlen(src)+1),sizeof(char)); my_strcpy(dst,src); printf("src = %s ",src); printf("dst = %s ",dst); for(i=0;i

Posteur · Answer

Génial  mamiemando ! ;-)

Ca fait plaisir de discuter avec un membre persistant de ce forum. :-) 

Plus clairement expliqué que ça on ne pouvait pas faire. Ce sera utile à beaucoup de programmeurs qui passeront par là. Bravo !

lami20j · Answer

Salut,

ou encorevoid strcpy4 (char *src, char *dst){
    while ((*dst++ = *src++) != '\0')
        ;
}ou encorevoid strcpy5(char *src, char *dst){
    while (*dst++ = *src++)
        ;
}

mamiemando · Answer

Pas de soucis ;)

[C++] Pointeur char*, priorité d'opérateur

6 réponses

Discussions similaires