Condiciones lógicas.

Anteriormente revisamos que una condición lógica da como resultado un valor lógico, el cual puede ser verdadero o falso. Es precisamente en las estructuras de control en donde se utilizan ampliamente la evaluación de condiciones lógicas, si revisas en la sección anterior, todas las estructuras hacen o no algo en función del resultado de evaluar una condición lógica.

En esta sección se profundizará en el uso de expresiones lógicas.

Nota: Aunque en este momento no le encuentres mucho sentido a los ejemplos siguientes, trata de seguirlos, en la siguiente sección todo empezará a tomar sentido.

Expresiones con 2 operandos

Las expresiones compuestas por 2 operandos son las más sencillas de evaluar, las cuales generan un valor dependiendo del operador utilizado. Considera las siguientes expresiones.

int eMinima = 18; //Establecemos la edad mínima aceptada
int eUsuario = 16; //Suponemos una edad para nuestro usuario
bool MayordeEdad;

Si evaluamos estas expresiones con los operadores relacionales más comunes tenemos:

Actualizamos la edad del usuario:

eUsuario = 18;

con este cambio nuestra evaluación de condiciones cambia del siguiente modo:

El siguiente programa ilustra la evaluación con operadores lógicos, probablemente te parezca muy simple, lo importante en este caso es que comprendas como se evalúan las expresiones y que modifiques el código para que observes los cambios en la ejecución.

/******************************************************************************
// operadoreslogicos.cpp
// Este programa muestra la evauación de 2 números con operadores lógicos
// 2017, Por http://about.me/carlosgbr
// Versión 1
// Compilado en https://www.onlinegdb.com/online_c++_compiler
*******************************************************************************/
#include <iostream>
using namespace std;
int main()
{
    int numero1 = 0, numero2=0;
    bool resultado;
    cout << "En este programa se evalúan expresiones lógicas\n";
    cout << "Introduce 2 cifras para que puedas compararlos:\n\n";
    cout << "Escribe un número (con o sin decimales), a continuación pulsa ENTER\n";
    cin >> numero1;
    cout << "Escribe otro número (con o sin decimales), a continuación pulsa ENTER \n";
    cin >> numero2;
    cout << "\n\n";
    cout << "Considera que 0 = Falso y 1 = Verdadero \n";
    cout << numero1 << " < "  << numero2  << " = "  << (numero1 < numero2) << "\n";
    cout << numero1 << " <= "  << numero2  << " = "  << (numero1 <= numero2) << "\n";
    cout << numero1 << " > "  << numero2  << " = "  << (numero1 > numero2) << "\n";
    cout << numero1 << " >= "  << numero2  << " = "  << (numero1 >= numero2) << "\n";
    cout << numero1 << " == "  << numero2  << " = "  << (numero1 == numero2) << "\n";
    cout << numero1 << " != "  << numero2  << " = "  << (numero1 != numero2) << "\n";
    cout << "not (" << numero1 << " != " << numero2 << ") = " << not (numero1 != numero2) << "\n";
    return 0;
}

Evaluando expresiones complejas

En ocasiones tendremos que evaluar 3 o más condiciones, por ejemplo considera el pago de comisiones para un empleado: Supongamos que se le dará bono de productividad solo si no tuvo faltas y si cumplió todas sus actividades durante el periodo evaluado. Si solo cumple una de las 2 solo se le darán $100.00 de comisión.

int limitefaltas = 0; //tolerancia de faltas para recibir bono
int faltasemp = 3; //Las faltas del empleado en el periodo
int act = 10; //actividades totales que debe hacer en el periodo
int actCumplidas = 12; // actividades realizadas
bool darBono; // Aquí se almacena si se dar no bono al empleado.

En este caso debemos evaluar y comparar las faltas y a parte las actividades cumplidas para determinar si le toca bono al empleado.

Codificando esta condición tenemos:

darBono = (limitefaltas <= faltasemp);

Por asistencia al empleado no le toca bono!

Codificando esta condición tenemos:

darBono = (act <= actCumplidas);

Por rendimiento al empleado sí le toca bono!

Ahora que sabemos que no le toca bono completo, debemos evaluar si merece al menos la comisión de $100.00 recuerda que la condición es que al menos una de las 2 se cumpla (sea verdadera), en este caso tenemos 2 expresiones que debemos evaluar, en estos casos utilizaremos los operadores Y lógico u O lógico, recuerda como trabajan estos operadores: Y sea cierto, solo si las 2 expresiones evaluadas son verdaderas, OR será verdadero solo si una de las 2 o las 2 expresiones son verdaderas, de este modo la expresión que hace lo que necesitamos es OR. Consulta la sección de Operadores para revisar en detalle este tema.

la evaluación la haremos de este modo:

Si codificamos esto en C++ la expresión resultante es:

darBono = (limitefaltas <= faltasemp) || (act <= actCumplidase);

Con esta sentencia podremos determinar si al menos le toca el bono opcional al empleado. Nota que las expresiones están agrupadas con paréntesis. Esto en necesario cuando evalúas expresiones compuestas.

Programa con expresiones complejas

El siguiente es un ejemplo que implementa la evaluación de las tablas de verdad que anteriormente se mostraron para los operadores AND y OR, por una parte, y la evaluación de dos expresiones compuestas por el otro. También notarás que se incluyó parte del código del programa anterior, te presente que es una práctica frecuente reutilizar tu propio código como el de terceros al realizar tus programas.

/******************************************************************************
// operadoreslogicos2.cpp
// Este programa muestra la evaluación de 2 números con operadores lógicos
// AND Y OR
// 2017, Por http://about.me/carlosgbr
// Versión 1
// Compilado en https://www.onlinegdb.com/online_c++_compiler
*******************************************************************************/
#include <iostream>
using namespace std;
int main()
{
    bool resp1 = true;
    bool resp2 = false;
    cout << "En este programa muestra las tablas de verdad para los operadores\n";
    cout << "AND (&) y OR ( ):\n\n";
    cout << "\n";
    cout << "Tabla de verdad para Y Lógico (AND, &)  \n";
    cout << "\tExpresión 1 \t& \tExpresión 2 \t -> \tResultado\n";
    cout << " \t" << true << " \t\t& "  << " \t" << true  << " \t\t= "  << " \t" << (true & true) << "\n";
    cout << " \t" << true << " \t\t& "  << " \t" << false  << " \t\t= "  << " \t" << (true & false) << "\n";
    cout << " \t" << false << " \t\t& "  << " \t" << true  << " \t\t= "  << " \t" << (false & true) << "\n";
    cout << " \t" << false << " \t\t& "  << " \t" << false  << " \t\t= "  << " \t" << (false & false) << "\n";
    //cout << "not (" << numero1 << " != " << numero2 << ") = " << not (numero1 != numero2) << "\n";
        cout << "\n";
    cout << "Tabla de verdad para O Lógico (OR, ||)  \n";
    cout << "\tExpresión 1 \t|| \tExpresión 2 \t -> \tResultado\n";
    cout << " \t" << true << " \t\t|| "  << " \t" << true  << " \t\t= "  << " \t" << (true || true) << "\n";
    cout << " \t" << true << " \t\t|| "  << " \t" << false  << " \t\t= "  << " \t" << (true || false) << "\n";
    cout << " \t" << false << " \t\t|| "  << " \t" << true  << " \t\t= "  << " \t" << (false || true) << "\n";
    cout << " \t" << false << " \t\t|| "  << " \t" << false  << " \t\t= "  << " \t" << (false || false) << "\n";
    //Ahora evaluamos expresiones introducidas por el usuario
    int numero1 = 0, numero2=0;
    char letra1, letra2;
    cout << "Introduce la información para que puedas compararla:\n";
    cout << "Escribe un número (sin decimales), a continuación pulsa ENTER\n";
    cin >> numero1;
    cout << "Escribe otro número (con o sin decimales), a continuación pulsa ENTER \n";
    cin >> numero2;
    cout << "Escribe una letra, a continuación pulsa ENTER\n";
    cin >> letra1;
    cout << "Escribe otra letra, a continuación pulsa ENTER \n";
    cin >> letra2;
    cout << "\n";
    cout << "Considera que 0 = Falso y 1 = Verdadero \n";
    //Imprementamos una expresión AND
    cout << numero1 << " < "  << numero2  << " = "  << (numero1 < numero2) << "\n";
    cout << letra1 << " < "  << letra2  << " = "  << (letra1 < letra2) << "\n";
    cout << "(" << letra1 << " < " << letra2 << ") & (" <<
          numero1 << " < " << numero2 << ") = " << ((letra1 < letra2) & (numero1 < numero2)) << "\n";
    //Imprementamos una expresión OR
    cout << numero1 << " < "  << numero2  << " = "  << (numero1 < numero2) << "\n";
    cout << letra1 << " < "  << letra2  << " = "  << (letra1 < letra2) << "\n";
    cout << "(" << letra1 << " < " << letra2 << ") || (" <<
          numero1 << " < " << numero2 << ") = " << ((letra1 < letra2) || (numero1 < numero2)) << "\n";
    return 0;
}

A continuación te muestro una salida del programa

Conclusión

Podrás pensar que es muy enredado esto, no lo es, tan solo requiere que pienses de forma lógica, y dicho sea de paso, siempre será recomendable que leas un poco de lógica booleana, en donde obtendrás muchas herramientas y el pensamiento abstracto para no perderte en este tipo de construcciones. Sin embargo en general no se requiere tanta profundidad, conque manejes las tablas de verdad para las funciones AND, OR, NOT, XOR Y NAND, es suficiente para la mayoría de los casos.

Por otra parte considera que para generar una simple sentencia debemos hacer muchas suposiciones, debes tener en cuenta que tú debes prever todas las posibilidades a las que tu programa debe responder de forma apropiada. Entre más suposiciones pueda prever tu programa, verás que crece el código del mismo.

Ahora sí, estamos listos para empezar a programar cosas más interesantes.

Fuente Imágenes

• «Estructuras de control»: by Pixabay
• «Todas las demás imágenes de esta sección»: by Nala Systems

Código Fuente

• Código fuente general del Tutorial: en Github
• El de ésta página:
  • operadoreslogicos.cpp
  • operadoreslogicos2.cpp

Evaluación de Condiciones Lógicas by Roberto C. González is licensed under a Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.