Disponible la nueva versión "donationware" 7.3 de OrganiZATOR
Descubre un nuevo concepto en el manejo de la información.
La mejor ayuda para sobrevivir en la moderna jungla de datos la tienes aquí.

Curso C++

[Home]  [Inicio]  [Índice]


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.8AND (&&) 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.