Ce n'while(*pointeur) signifie en C?

while(x) {
    do_something();
}

sera exécuté do_something() à plusieurs reprises, tant que x est vrai. En C, le "vrai" signifie "pas de zéro".

'\0' est un caractère nul. Numériquement, c'est le zéro (les bits qui représente '\0' est le même que le nombre de zéro; tout comme un espace est le nombre 0x20 = 32).

Si vous avez while(*pointer != '\0'). Tandis que la pointe-à -la mémoire n'est pas un zéro octet. Plus tôt, j'ai dit "vrai" signifie "non-zéro", de sorte que la comparaison x != 0 (si x est int, short, etc.) ou x != '\0' (si x est char), les mêmes que juste x à l'intérieur d'un if, while, etc.

Devriez-vous utiliser ce formulaire plus court? À mon avis, non. Il en fait de moins en moins claires à quelqu'un de lire le code que l'intention est. Si vous écrivez la comparaison explicitement, il est beaucoup plus évident que l'intention de la boucle, même si techniquement ils signifient la même chose pour le compilateur.

Donc si vous écrivez while(x), x doit être un booléen ou un C int qui représente une valeur booléenne (vrai ou faux concept) déjà. Si vous écrivez while(x != 0), puis vous vous souciez de x étant un entier différent de zéro et sont en train de faire quelque chose de numérique avec x. Si vous écrivez while(x != '\0'), puis x est un char et que vous voulez continuer jusqu'à ce que vous trouver un caractère null (vous êtes probablement le traitement d'une chaîne C).

OriginalL'auteur Laogeodritt

Oui, vous pouvez aller pour elle.

Veuillez noter que *pointer est la valeur à l'emplacement de la mémoire de la pointer point(ou contenir l'adresse de l').

Votre *pointer est maintenant pointant vers chacun des caractères du tableau de caractères var.

Donc, while(*pointer) est une abréviation de l'utilisation de l'équivalent

while(*pointer!='
while(*pointer!='\0').
').

Supposer, votre chaîne est initialisée à 9 caractères dire "123456789" et situé à une adresse de dire addr(emplacement de la mémoire).

Maintenant, à cause de la déclaration:

char *pointer=&var;

pointer pointe vers le premier élément de la chaîne "1234567890".

Lorsque vous écrivez le *pointer, elle récupère la valeur stockée à l'emplacement de la mémoire addr qui est 1.

Maintenant, l'instruction:

while(*pointer)

sera équivalent à

while(49)

parce que la Valeur ASCII de 1 est de 49, et la condition est évaluée à vrai.

Cela continuera jusqu'à ce que \0 personnage est atteint après l'incrémentation pointer pour neuf fois.

Maintenant, l'instruction:

while(*pointer)

sera équivalent à

while(0)

parce que la valeur ASCII de \0 est 0. Ainsi, la condition est évaluée à faux et la boucle s'arrête.

Résumé:

• Dans while(condition), condition doit être non nul de poursuivre l'exécution de la boucle. Si condition évalue à zero puis la boucle s'arrête l'exécution.

• while(*pointer) travaillera jusqu'à la valeur de l'emplacement de mémoire d'être souligné est un non-zero valeur ASCII.

• Aussi, vous pouvez utiliser:

  if(*ptr){     //instead of if(*ptr!='
  if(*ptr){     //instead of if(*ptr!='\0')
  //do somthing
  }
  if(!*ptr){     //instead of if(*ptr=='\0')
  //do somthing
  }
  ')
    //do somthing
  }
  
  if(!*ptr){     //instead of if(*ptr=='
  if(*ptr){     //instead of if(*ptr!='\0')
  //do somthing
  }
  if(!*ptr){     //instead of if(*ptr=='\0')
  //do somthing
  }
  ')
    //do somthing
  }

OriginalL'auteur TryinHard

Commençons par un exemple simple::

int a = 2 ;
int *b = &a ;
/* Run the loop till *b i.e., 2 != 0 
Now, you know that, the loop will run twice 
and then the condition will become false 
*/
while( *b != 0 )
{
 *b-- ;
}

De la même façon, votre code est de travailler avec char*, une chaîne de caractères.

char var[10] ;
/* copy some string of max char count = 9, 
and append the end of string with a '
char var[10] ;
/* copy some string of max char count = 9, 
and append the end of string with a '\0' char.*/
char *pointer = &var ;
while( *pointer != '\0' )
{
//do something
//Increment the pointer 1 or some other valid value
}
' char.*/
char *pointer = &var ;
while( *pointer != '
char var[10] ;
/* copy some string of max char count = 9, 
and append the end of string with a '\0' char.*/
char *pointer = &var ;
while( *pointer != '\0' )
{
//do something
//Increment the pointer 1 or some other valid value
}
' )
{
 //do something
 //Increment the pointer 1 or some other valid value
}

Donc, la boucle sera exécutée jusqu'à *pointer de ne pas frapper '\0'.

while( *pointer )
/* The above statement means the same as while( *pointer != '
while( *pointer )
/* The above statement means the same as while( *pointer != '\0' ),
because, null char ('\0') = decimal value, numeric zero, 0*/
' ),
because, null char ('
while( *pointer )
/* The above statement means the same as while( *pointer != '\0' ),
because, null char ('\0') = decimal value, numeric zero, 0*/
') = decimal value, numeric zero, 0*/

Mais l'usage peut changer lorsque vous le faites, while(*pointer != 'x'), where x can be any char. Dans ce cas, votre premier code de sortie après *pointer hits the 'x' char mais votre deuxième extrait de courir jusqu'à *pointer hits '\0' char.

OriginalL'auteur Abhineet