bool, false, true

3.2.1b bool, false, true

§1 Sinopsis

La palabra-clave bool declara un tipo especial de variable, denominada booleana ( 0.1) que solo puede tener dos valores: cierto y falso [1].

Nota: por razón de los valores que pueden adoptar (cierto/falso), a estas variables también se las denomina variables lógicas.

§2 Sintaxis

bool <identificador>;

§3 Descripción

Evidentemente el tipo bool está especialmente adaptado a para realizar comprobaciones lógicas; de hecho, todo el álgebra de Boole se basa justamente en el uso de este tipo de variables de solo dos valores mutuamente excluyentes.

Por su parte, las palabras clave false y true son literales que tienen valores predefinidos (podemos considerar que son objetos de tipo booleano de valor constante predefinido). false tiene el valor falso (numéricamente es cero), true tiene el valor cierto (numéricamente es uno). Estos literales booleanos son Rvalues; no se les puede hacer una asignación (no pueden estar a la izquierda de una asignación 2.1).

bool val = false; // declara val variable Booleana y la inicia

val = true; // ahora se cambia su valor (nueva asignación)

true = 0; // Error!!

§4 Conversión (modelado) de tipos:

Tenga en cuenta que los bool y los int son tipos distintos. Sin embargo, cuando es necesario, el compilador realiza una conversión o modelado automático (), de forma que pueden utilizarse libremente valores bool (true y false) junto con valores int sin utilizar un modelado explícito. Por ejemplo:

int x = 0, y = 5;

if (x == false) printf("x falso.\n"); // Ok.

if (y == truee) printf("y cierto.\n"); // Ok.

if ((bool) x == false) printf("x falso.\n"); // Modelado innecesario

Estas conversiones entre tipos lógicos y numéricos, son simplemente una concesión del C++ para poder aprovechar la gran cantidad de código C existente. Tradicionalmente en C se hacía corresponder falso con el valor cero y cierto con el valor uno (o distinto de cero).

El proceso consiste en que, en las expresiones aritméticas y lógicas, las variables booleanas son convertidas a enteros (int). Las operaciones correspondientes (aritméticas y lógicas) se realizan con enteros, y finalmente el resultado numérico es vuelto a bool según las reglas de conversión siguientes:

Para convertir tipos bool a tipos int: false cero
true uno
Para convertir tipos int a un Rvalue tipo bool: cero false
cualquier otro valor true.

Para el resto de variables distintas de int (aunque sean numéricas), antes de utilizarlas en expresiones lógicas ( 4.9.9), es necesario un modelado ("casting"). Ejemplo:

float x = 0

long y = 5;

int *iptr = 0;

if (x == false) printf("x falso"); // Error.

if (y == truee) printf("y cierto"); // Error.

if (iptr == false) printf("Puntero nulo"); // Error.

if ((bool) x == false) printf("x falso"); // Ok.

if ((bool) y == true) printf("y cierto"); // Ok.

if ((bool) iptr == false) printf("Puntero nulo"); // Ok.

Las reglas son análogas a las anteriores:

Para convertir un Rvalue tipo bool a un Rvalue numérico: false cero
true uno.
Para convertir tipos aritméticos (enumeraciones, punteros o punteros a miembros de clases) a un Rvalue de tipo bool, la regla es que cualquier valor cero; puntero nulo, o puntero a miembro de clase nulo, se convierte a false. Cualquier otro valor se convierte a true.

§5 Los tipos bool y los literales false y true se pueden utilizar para realizar comprobaciones lógicas. En el ejemplo que sigue se muestra como hacer test booleanos con bool, true, y false:

#include <iostream>

using std::cout;

using std::endl;

bool func() { // Func devuelve un tipo bool

return NULL; /* NULL es convertido a Booleano (false)

return false; esta sentencia es idéntica a la anterior */

}

int main() { // ==============

bool val = false; // val es declarada tipo bool e iniciada

int i = 1; // i es tipo int (no booleano)

int *iptr = 0; // puntero nulo, equivale a: int *iptr = NULL

float j = 1.01; // j es tipo float (no booleano)

// Test para enteros

if (i == true) cout << "Cierto: el valor es 1" << endl;

if (i == false) cout << "Falso: el valor es 0" << endl;

// Test para punteros

if ((bool) iptr == false) cout << "Puntero no válido" << endl;

// Para comprobar el valor j se "modela" a tipo bool.

if ((bool) j == true) cout << "el Booleano j es cierto" << endl;

// Test de función devolviendo Booleano

val = func();

if (val == false)

cout << "func() devuelve falso.";

if (val == true)

cout << "func() devuelve cierto.";

return false; // false es convertido a 0 (int)

}

Salida del programa:

Cierto: el valor es 1

Puntero no válido

el Booleano j es cierto

func() devuelve falso

§6 El lenguaje C++ tiene operadores y sentencias en las que se exige la presencia de un tipo bool, son las siguientes:

Operadores lógicos ( 4.9.8) AND (&&) OR (||) NOT (!). Producen un resultado booleano, y sus operandos son también valores lógicos o asimilables a ellos (los valores numéricos son asimilados a true o false según su valor).
Operadores relacionales ( 4.9.12) <, >, <=, >=. Aceptan diversos tipos de operando, pero el resultado es de tipo booleano.
Expresión condicional en las sentencias if ( 4.10.2) y en las iteraciones for, while y do..while ( 4.10.3). En todos estos casos, la sentencia condicional produce un bool como resultado.
El primer operando del operador ? : ( 4.9.6), es convertido a bool.

Inicio.

[1] El tipo bool es una incorporación reciente del lenguaje (1998), que tiene antecedentes en muchos otros lenguajes de programación. Por ejemplo Pascal.

Inicio