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');

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é).

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 <stdlib.h>
#include <stdio.h>
#include <string.h>

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\n",src);
    printf("dst = %s\n",dst);
    free(dst);
    return 0;
}

(mando@polgara) (~) $ gcc -W -Wall plop.c
(mando@polgara) (~) $ ./a.out
src = tapir
dst = tapir

void my_strcpy2(char *dst,char *src){
    while(*src != '\0') *dst++ = *src++;
}

void my_strcpy3(char *dst,char *src){
    for(;*src != '\0';++src,++dst) *dst = *src;
}

for(i=0;i<10;++i) printf("%d\n",i);
for(i=0;i<10;i++) printf("%d\n",i);

void my_strcpy_bug(char *dst,char *src){
    while(*src != '\0') *++dst = *++src;
}

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

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\n",src);
    printf("dst = %s\n",dst);

    for(i=0;i<strlen(src);++i) printf("dst[%i]='%c'\n",i,dst[i]);
    free(dst);
    return 0;
}

(mando@polgara) (~) $ ./a.out
src = tapir
dst =
dst[0]=''
dst[1]='a'
dst[2]='p'
dst[3]='i'
dst[4]='r'

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 !

Salut,

ou encore

void strcpy4 (char *src, char *dst){
    while ((*dst++ = *src++) != '\0')
        ;
}

void strcpy5(char *src, char *dst){
    while (*dst++ = *src++)
        ;
}

Pas de soucis ;)