‘\ 0’ évalue faux, “\ 0” évalue vrai

Inspiré par un programme décrit dans la section 5.5 de K & R :

void strcpy(char *s, char *t) { while(*s++ = *t++); } 

Programme C

 if ('\0') { printf("\'\\0\' -> true \n"); } else { printf("\'\\0\' -> false\n"); } if ("\0") { printf("\"\\0\" -> true \n"); } else { printf("\"\\0\" -> false\n"); } 

estampes

 '\0' -> false "\0" -> true 

Pourquoi '\0' et "\0" évalués différemment dans C?

Clang version 3.8.0

Rappelez-vous comment les littéraux de chaîne fonctionnent en C – "\0" est un tableau de caractères contenant deux octets de zéro (celui que vous avez demandé et celui implicite à la fin). Lorsqu’il est évalué pour le test if , il se désintègre en un pointeur vers son premier caractère. Ce pointeur n’est pas NULL, il est donc considéré comme vrai lorsqu’il est utilisé comme condition.

'\0' est le nombre zéro, équivalent à seulement 0 . C’est un entier qui est zéro, donc il est considéré comme faux lorsqu’il est utilisé comme condition.

Tout d’abord, vous devez garder à l’esprit que dans C,

  • Zéro est faux et non nul est vrai.
  • Pour les types de pointeurs, NULL est faux et non NULL est vrai.

'\0' , comme d’autres l’ont dit, est le même que le littéral entier 0 et est donc faux (voir le premier point ci-dessus pour savoir pourquoi).

"\0" est un littéral de chaîne contenant deux \0 caractères (un que vous avez explicitement ajouté et l’autre implicite et qui sera ajouté par le compilateur). Le littéral de chaîne sera stocké quelque part dans la mémoire morte. Lorsque vous utilisez "\0" , il est converti en un pointeur sur son premier élément . Ceci est communément appelé ” désintégration de tableau “. (C’est la raison pour laquelle des choses comme char* str = "ssortingng"; fonctionne).

Donc, vous vérifiez effectivement l’adresse du premier caractère du littéral de chaîne . Puisque l’adresse du littéral de chaîne sera toujours non NULL , le if sera toujours vrai (voir le deuxième point ci-dessus pour savoir pourquoi).


: Ce “déclin” des tableaux ne se produit pas toujours. Voir Exception à la masortingce ne se décompose pas en pointeur?

'\0' est un nombre: 0 , donc il est évalué comme faux ( 0 = faux !0 = vrai).

Mais "\0" est un pointeur sur une section en lecture seule où la chaîne réelle est stockée, le pointeur n’est pas NULL ergo c’est vrai.

Tout d’abord, en regardant les deux conditions, '\0' est une constante de type entier, qui indique le caractère nul C, qui est identique à 0 . Alors que "\0" est un littéral de chaîne, qui contient 2 octets, celui spécifié et le caractère de terminaison null implicitement ajouté. Étant un littéral de chaîne, le pointeur ne peut pas être NULL .

Deuxièmement, en C, pour la condition de l’instruction if , tout ce qui est non nul est évalué comme true , et zéro est évalué comme false .

Selon cette règle, il sera clair que '\0' est false et que "\0" évalué comme true .

Tout d’abord, notez que la valeur hexadécimale de False est 0x00 et True toute autre valeur que 0x00.

"\0" est une chaîne avec un caractère et Null Terminator '\0' à la fin. C’est donc un pointeur de caractère, pointant vers un tableau de 2 octets: ['\0', '\0'] . Dans ce tableau, le premier est le caractère et l’autre est le terminateur nul.

Après la compilation (sans optimisation), ce pointeur de caractère est temporairement affecté à une adresse dans la mémoire pointant vers le premier octet de ces deux octets. Cette adresse peut être, par exemple, 0x18A6 en hexadécimal. Le compilateur (la plupart d’entre eux) écrit donc ces deux valeurs dans la mémoire. Comme une chaîne est en fait l’adresse du premier octet de cette chaîne, notre expression est interprétée comme 0x18A6 != false . Donc, il est clair que 0x18A6 != 0x00 est vrai.

'\0' est simplement 0x00 en hexadécimal. 0x00 != 0x00 est faux.

Cette réponse est écrite pour une architecture de données 8 bits avec adressage 16 bits. J’espère que ça aide.

‘\ 0’ est un caractère nul qui a la valeur 0 . Il est utilisé pour terminer une chaîne de caractères. Donc, c’est considéré comme faux.

“\ 0” est une chaîne vide ou vide . Le seul caractère de la chaîne est le caractère null qui termine la chaîne.

Nous pouvons clarifier ci-dessus problème dans deux concept différents de C

  1. Travail de si (condition) en C
  2. Différence de littéraux de caractères et de chaînes en C

1. Travail de (condition) en C si (condition)

En langage C, si la condition fonctionne sur la base 0 (zéro) et non zéro.

Si le résultat de la condition donnée est zéro, alors C considère que cette condition donnée est fausse.

Si le résultat de la condition donnée est non nul, C considère que la condition donnée est vraie.

2. Différence de littéraux de caractères et de chaînes en C

Dans C, les littéraux Ssortingng sont ceux qui entourent les guillemets doubles (“”), tandis que les littéraux caractères sont ceux qui entourent les guillemets simples (”) et la longueur minimale est un caractère et la longueur max.

Un autre point important est que dans C, si nous convertissons ‘\ 0’ (null) en int (Integer), alors nous aurons 0 (Zero), alors que nous ne pouvons pas convertir implicitement ou explicitement “\ 0” en int. Parce que “\ 0” est une chaîne alors que “\ 0” est un caractère.

Et selon la logique de travail de condition de chaîne IF, si la condition renvoie 0 ou false, cela signifie que la condition est fausse; en cas de condition qui ne soit pas nulle, cela signifie que la condition est vraie.

Donc, selon les points 1 et 2, nous pouvons conclure que

if (‘\ 0’) printf (“\ ‘\ 0 \’! = false \ n”); // la condition devient fausse

if (“\ 0”) printf (“\” \ 0 \ “! = false \ n”); // la condition devient vraie

‘\ 0’ est un caractère égal au nombre zéro. “\ 0” est une chaîne et nous ajoutons habituellement “\ 0” à la fin d’une chaîne. N’utilisez pas ‘\ 0’ ou “\ 0” dans une instruction conditionnelle car c’est assez déroutant.

L’utilisation suivante est suggérée:

 if (array[0] != 0) { } if (p != 0) { } if (p != NULL) { } 

Découvrez ceci avec des exemples ..

 #include  int main() { printf( "ssortingng value\n" ); //the integer zero printf( "0.........%d\n" , 0 ); //the char zero, but chars are very small ints, so it is also an int //it just has some special syntax and conventions to allow it to seem //like a character, it's actual value is 48, this is based on the //ASCII standard, which you can look up on Wikipedia printf( "'0'.......%d\n" , '0' ); //because it is an integer, you can add it together, //'0'+'0' is the same as 48+48 , so it's value is 96 printf( "'0'+'0'...%d\n" , '0'+'0' ); //the null terminator, this indicates that it is the end of the ssortingng //this is one of the conventions ssortingngs use, as a ssortingng is just an array //of characters (in C, at least), it uses this value to know where the array //ends, that way you don't have to lug around another variable to track //how long your ssortingng is. The actual integer value of '\0' is zero. printf( "'\\0'......%d\n" , '\0' ); //as stated, a ssortingng is just an array of characters, and arrays are tracked //by the memory location of their first index. This means that a ssortingng is //actually a pointer to the memory address that stores the first element of //the ssortingng. We should get some large number, a memory address printf( "\"0\".......%d\n" , "0" ); //a ssortingng is just an array of characters, so lets access the character //in position zero of the array. it should be the character zero, which //has an integer value of 48 printf( "\"0\"[0]....%d\n" , "0"[0] ); //and the same thing for the empty ssortingng printf( "\"\\0\"[0]...%d\n" , "\0"[0] ); //equal to '\0' //we also said a ssortingng is just a pointer, so we should be able to access //the value it is pointing to (the first index of the array of characters) //by using pointers printf( "*\"0\"......%d\n" , *"0" ); return 0; }