c++ - visual - que es if else en programacion

¿Los números negativos devuelven falso en C/C++?

Question

Al evaluar enteros como booleanos en C / C ++, ¿los números negativos son verdaderos o falsos? ¿Son siempre verdaderos / falsos independientemente de los compiladores?

Answer 1

Buena pregunta. La respuesta es "depende".

if (-1) { // this is always true
}

Por otro lado, supongamos que está en una máquina de 16 bits:

if (-65536) { // this is always false
}

Por otra parte,

int a = whatever doesn''t matter;
if (a < 0) { // this might or might not be true
    if (a) { // this will always be true if we get here
    }
}

Entonces, los números negativos no siempre son falsos, excepto que a veces siempre lo son.

Answer 2

Puede probarlo usted mismo compilando esto:

#include <stdio.h>

int main(int argc, char** argv) {
    if (-1) {
        printf("-1 is true/n");
    } else {
        printf("-1 is false/n");
    }
    return 0;
}

Resultados:

$ gcc -Wall -pedantic test.c -o test-c
$ g ++ -Wall -pedantic test.c -o test-cpp
$ ./test-c
-1 es cierto
$ ./test-cpp
-1 es cierto

Por supuesto, para responder a la segunda parte de su pregunta, "¿Son siempre verdaderos / falsos independientemente de los compiladores?", La única manera de estar completamente seguro es mirar las especificaciones. En general, sin embargo, los compiladores te advertirán si haces algo peligroso, y puedes ver en el resultado anterior, que incluso con warnings "pedantes", gcc considera que este código está perfectamente bien.

Answer 3

Respuesta corta: Sí, los valores negativos, y cualquier valor distinto de cero en general, se tratan como verdaderos cuando se usan como condiciones.

Para C, hay una serie de contextos en los que una expresión se trata como una condición. Las condiciones no son necesariamente del tipo bool o _Bool ; ese tipo solo se agregó al idioma según el estándar de 1999.

El más obvio de estos contextos es la expresión en una instrucción if , pero hay otros ejemplos: while , do-while , la segunda expresión en un encabezado for , el primer operando del operador ?: conditional, y el operando (s) del ! , && , y || operadores. ( Creo que es una lista exhaustiva, pero no estoy seguro).

Esto es lo que dice el estándar C sobre el comportamiento de la sentencia if (las "dos formas" se refieren a if con y sin una cláusula else ):

En ambas formas, la primera subestimación se ejecuta si la expresión compara desigual a 0.

Lo que significa que esto:

if (foo) ...

es equivalente a esto:

if ((foo) != 0) ...

(agregando paréntesis adicionales para evitar problemas de precedencia del operador). El significado es claro si foo es de tipo int . Si foo es de algún tipo de punto flotante, 0 se convierte al mismo tipo (lo que puede causar algunas sutilezas si el valor pasa a ser un cero negativo o un NaN). Y si foo es un puntero, 0 se trata como una constante de puntero nulo; if (ptr) es equivalente a if (ptr != NULL) (suponiendo que la definición de NULL es visible).

Para C ++, las reglas se establecen de forma un poco diferente, pero el efecto es el mismo. La condición en una sentencia C ++ if se convierte a tipo bool (a diferencia de C, el tipo bool se ha integrado en C ++ desde su inicio). La conversión de un valor de cualquier tipo escalar a bool está definida por el estándar de C ++ como:

Un valor cero, un valor de puntero nulo o un valor de puntero de miembro nulo se convierte en falso ; cualquier otro valor se convierte en verdadero. Un prvalue de tipo std :: nullptr_t se puede convertir a un prvalue de tipo bool ; el valor resultante es falso .

Entonces, tanto en C como en C ++, cualquier valor escalar (es decir, entero, punto flotante o puntero) se puede usar como condición, y la condición es falsa si el escalar es igual a cero, y verdadero si no es igual a cero . C define esto como una comparación de desigualdad a 0 ; C ++ lo define como una conversión al bool , pero el resultado es el mismo.

Esto se está alejando un poco del tema de la pregunta, pero mencionaré que es importante tener en cuenta que un valor que se trata como una condición verdadera no es necesariamente igual a true . true (que es 1 en C si tiene #include <stdbool.h> , y un valor único de tipo bool en C ++) es solo uno de los muchos valores que poseen "veracidad" cuando se usa en una condición. Por eso casi nunca deberías escribir:

if (cond == true) ...

en C o C ++ (a menos que realmente necesites compararlo con ese único valor); solo escribe:

if (cond) ...

Un ejemplo de C ++:

#include <iostream>
int main() {
    int n = 2;
    if (n)         std::cout << "n has truthiness/n";
    else           std::cout << "n does not have truthiness/n";
    if (n == true) std::cout << "n == true/n";
    else           std::cout << "n != true/n";
}

El resultado es:

n has truthiness
n != true

Answer 4

Todo lo que no sea 0 se convertirá en true ( 1 en el caso de C ), un valor zero se convertirá en false ( 0 en el caso de C ). Con respecto a C, si miramos el borrador de la norma C99, sección 6.3.1.2 el párrafo de tipo booleano 1 dice:

Cuando cualquier valor escalar se convierte a _Bool, el resultado es 0 si el valor se compara con 0; de lo contrario, el resultado es 1.

Para completar, si miramos la sección 7.16 tipo booleano y valores, el párrafo 2 dice:

The macro 

 bool

expands to _Bool.

con respecto a C ++, el borrador del estándar de C ++ en la sección 4.12 conversiones booleanas, párrafo 1, dice (el énfasis es mío ):

Un prvalor de enumeración aritmética, sin cobertura, puntero o puntero a tipo de miembro se puede convertir a un prvalue de tipo bool. Un valor cero, un valor de puntero nulo o un valor de puntero de miembro nulo se convierte en falso; cualquier otro valor se convierte en verdadero. [...]

Esto debería ser válido independientemente del compilador que use.

Answer 5

Todos los valores distintos de cero se convertirán a true y cero a false . Con números negativos que no son cero, se convierten a true .

Citando del estándar C ++ 11 (énfasis mío):

4.12 conversiones booleanas [conv.bool]

1 Un valor pr de cálculo aritmético, enumeración no codificada, puntero o puntero a tipo de miembro se puede convertir a un prvalue de tipo bool. Un valor cero, un valor de puntero nulo o un valor de puntero de miembro nulo se convierte en false ; cualquier otro valor se convierte en true . Un prvalue de tipo std :: nullptr_t se puede convertir a un prvalue de tipo bool; el valor resultante es falso.

¿Son siempre verdaderos / falsos independientemente de los compiladores?

Solo obtendrá la garantía anterior cuando su compilador cumpla con los estándares o, al menos, cumpla con esta parte específica del estándar. En la práctica, todos los compiladores tienen este comportamiento estándar, por lo que no hay mucho de qué preocuparse.