c - ''/ 0'' evalúa falso, “/ 0” evalúa verdadero

arrays string

Question

Inspirado en un programa descrito en K&R sección 5.5:

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

Programa C

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

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

huellas dactilares

''/0'' -> false
"/0" -> true

¿Por qué ''/0'' y "/0" evalúan de manera diferente en C?

clang versión 3.8.0

Answer 1

''/ 0'' es un carácter que es igual al número cero. "/ 0" es una cadena y generalmente agregamos ''/ 0'' al final de una cadena. No use ''/ 0'' o "/ 0" en declaraciones condicionales porque es bastante confuso.

Se sugiere el siguiente uso:

if (array[0] != 0)
{

}

if (p != 0)
{

}

if (p != NULL)
{

}

Answer 2

En primer lugar, debe tener en cuenta que en C,

• El cero es falso y el no cero es verdadero.
• Para los tipos de puntero, NULL es falso y non- NULL es verdadero.

''/0'' , como han dicho otros, es lo mismo que el entero 0 literal y, por lo tanto, es falso (consulte el primer punto anterior para saber por qué).

"/0" es un literal de cadena que contiene dos caracteres /0 (uno que ha agregado explícitamente y el otro, que está implícito y será agregado por el compilador). El literal de cadena se almacenará en algún lugar de la memoria de solo lectura. Cuando usa "/0" , se convierte en un puntero a su primer elemento ^† . Esto se conoce comúnmente como " decaimiento de la matriz ". (Esta es la razón por la cual cosas como char* str = "string"; funciona).

Por lo tanto, está comprobando efectivamente la dirección del primer carácter del literal de cadena . Dado que la dirección del literal de cadena siempre será no NULL , el if siempre será verdadero (consulte el segundo punto anterior para saber por qué).

^† : Esta "descomposición" de las matrices no siempre ocurre. ¿Ve Exception to array no decayendo en un puntero?

Answer 3

En primer lugar, tenga en cuenta que el valor hexadecimal de False es 0x00 y True es cualquier otro valor que no sea 0x00.

"/0" es una cadena con un carácter y un terminador nulo ''/0'' al final. Por lo tanto, es un puntero de caracteres que apunta a una matriz de 2 bytes: [''/0'', ''/0''] . En esta matriz, el primero es el carácter y el otro es el terminador nulo.

Después de compilar (sin optimizar), este puntero de caracteres se asigna temporalmente a una dirección en la memoria que apunta al primer byte de estos dos bytes. Esta dirección podría ser, por ejemplo, 0x18A6 en hexadecimal. Entonces el compilador (la mayoría de ellos) en realidad escribe estos dos valores en la memoria. Debido a que una cadena es en realidad la dirección del primer byte de esa cadena, nuestra expresión se interpreta como 0x18A6 != false . Entonces, está claro que 0x18A6 != 0x00 es verdadero.

''/0'' es simplemente 0x00 en hexadecimal. 0x00 != 0x00 es falso.

Esta respuesta está escrita para la arquitectura de datos de 8 bits con direccionamiento de 16 bits. Espero que eso ayude.

Answer 4

Lo simple es ATLEAST 0 (int) y 0.0 (float o double) tienen valor FALSE en C.

''/ 0'' es entero 0.

"/ 0" es una matriz de caracteres. No importa que dentro de la matriz cuántos caracteres hay o cuáles son esos caracteres.

Entonces, ''/ 0'' se evalúa a 0 como 77-77 se evalúa a 0. Y 0 es falso.

int x; x = ''/0''; printf("X has a value : %d"); Salida:

x tiene un valor: 0

Y el codigo:

if(0){printf("true");}

else{printf("false");}

Salida:

falso

Answer 5

Mira esto con ejemplos ...

#include <stdio.h> 

int main() 
{ 
printf( "string 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 string 
//this is one of the conventions strings use, as a string 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 string is. The actual integer value of ''/0'' is zero. 
printf( "''//0''......%d/n" , ''/0'' ); 

//as stated, a string is just an array of characters, and arrays are tracked 
//by the memory location of their first index. This means that a string is 
//actually a pointer to the memory address that stores the first element of 
//the string. We should get some large number, a memory address 
printf( "/"0/".......%d/n" , "0" ); 

//a string 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 string 
printf( "/"//0/"[0]...%d/n" , "/0"[0] ); //equal to ''/0'' 

//we also said a string 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; 
}

Answer 6

Podemos aclarar el problema anterior en dos conceptos diferentes de C

1. Trabajo de if (condición) en C
2. Diferencia de caracteres y literales de cadena en C

1. Trabajo de if (condición) en C if (condición)

En lenguaje C, si la condición funciona en 0 (cero) y en una base distinta de cero.

Si el resultado de la condición dada es Cero, entonces C considera que la condición dada es falsa.

Si el resultado de la condición dada no es cero, entonces C considera que la condición dada es verdadera.

2. Diferencia de caracteres y literales de cadena en C

En C, los literales de cadena son los que están entre comillas dobles (""), mientras que los literales de caracteres son los que están entre comillas simples ('''') y la longitud mínima es un carácter y la longitud máxima es dos caracteres.

Otro punto importante es que en C, si convertimos ''/ 0'' (nulo) a int (Entero), obtendremos 0 (Cero), mientras que no podemos convertir "/ 0" a int implícita o explícitamente. Porque "/ 0" es una cadena mientras que ''/ 0'' es un carácter.

Y de acuerdo con la lógica de funcionamiento de la condición IF de cadena, si la condición devuelve 0 o falso, significa que la condición es falsa; en caso de que la condición devuelva un valor distinto de cero, significa que la condición es verdadera.

Entonces, de acuerdo con los puntos 1 y 2, finalmente podemos concluir que

if (''/ 0'') printf ("/ ''/ 0 /'! = false / n"); // la condición se vuelve falsa

if ("/ 0") printf ("/" / 0 / "! = false / n"); // la condición se vuelve verdadera

Answer 7

Primero, mirando las dos condiciones, ''/0'' es una constante de tipo entero, que denota el carácter nulo C, que es igual a 0 . Mientras que "/0" es un literal de cadena, que contiene 2 bytes, el especificado y el byte terminador nulo se agrega implícitamente. Al ser un literal de cadena, el puntero no puede ser NULL .

En segundo lugar, en C, para la condición de la instrucción if , todo lo que no sea cero se evalúa como true y cero se evalúa como false .

De acuerdo con esta regla, quedará claro que ''/0'' es false y "/0" evaluado como true .

Answer 8

Recuerde cómo funcionan los literales de cadena en C: "/0" es una matriz de caracteres que contiene dos bytes cero (el que solicitó y el implícito al final). Cuando se evalúa para la prueba if , se desintegra en un puntero a su primer carácter. Este puntero no es NULL, por lo que se considera verdadero cuando se usa como condición.

''/0'' es el número cero, equivalente a solo 0 . Es un número entero que es cero, por lo que se considera falso cuando se usa como condición.

Answer 9

''/0'' es un número: 0 , por lo que se evalúa como falso ( 0 = falso !0 = verdadero).

Pero "/0" es un puntero a una sección de solo lectura donde se almacena la cadena real, el puntero no es NULL lo que es cierto.

Answer 10

''/ 0'' es un carácter nulo que tiene el valor de 0 . Se usa para terminar una cadena de caracteres. Entonces se considera falso.

"/ 0" es una cadena nula o vacía . El único carácter en la cadena es el carácter nulo que termina la cadena, por lo que se considera verdadero.