¿Alguien puede explicar qué está sucediendo exactamente en estas dos declaraciones enumeradas a continuación:

1) int enabled = val == 0; //val is an int

2) int sync = param || (foo->delay == NULL); //param and delay is both int
c
-2
blackbeard 23 ene. 2018 a las 19:59

3 respuestas

La mejor respuesta
int enabled = val == 0;

Leído como

int enabled = (val == 0);

Y

(val == 0)

Será 0 o no cero si val es 0 o no. enabled se inicializará con ese valor

Equivalente a:

int enabled;
if(val == 0)
{
    enabled = 1;
}
else
{
    enabled = 0;
}

Ahora haces el mismo análisis en el segundo

6
machine_1 23 ene. 2018 a las 17:11

C solo adoptó un tipo booleano verdadero de C ++ con C99, aunque lo nombró _Bool para que no entrara en conflicto con el código preexistente y proporcionó el encabezado <stdbool.h> para hacerlo más agradable.
La convención anterior de que solo 0 se considera falsey (un cero literal, que en un contexto de puntero es un puntero nulo), y no se cambió nada de verdad. (Eso es lo contrario a cómo lo hacen los shells de comando).

Todos los operadores booleanos y la conversión de _Bool usan valores canónicos de 0 y 1.

Eso debería ser suficiente historia y detalles para entender el código.

2
Deduplicator 23 ene. 2018 a las 17:11

Establecerá la variable enabled en 1 si val es igual a 0 y 0 de lo contrario.

sync será igual a 1 si param no es cero y, en caso de que sea 0, será 1 si foo->delay es NULL más será 0.

De estándar §6.5.9p3 respaldando lo que dije :

Los operadores == (igual a) y != (no igual a) son análogos a los operadores relacionales, excepto por su precedencia más baja.108) Cada uno de los operadores produce 1 si la relación especificada es verdadero y 0 si es falso. El resultado tiene el tipo int. Para cualquier par de operandos, exactamente una de las relaciones es verdadera.

También en el caso || hay un estándar que dice la lógica de evaluación: del §6.5.14

A diferencia de los bit a bit | operador, el operador || garantiza una evaluación de izquierda a derecha; si se evalúa el segundo operando, hay un punto de secuencia entre las evaluaciones del primer y segundo operandos. Si el primer operando se compara desigual a 0, el segundo operando no se evalúa.

También en la misma sección, la regla que dicta cuál será el resultado si param no es cero.

El operador || arrojará 1 si alguno de sus operandos se compara desigual con 0; de lo contrario, produce 0. El resultado tiene el tipo int.

4
user2736738 23 ene. 2018 a las 17:20