Expresiones lógicas

De la evaluación de una expresión lógica siempre se obtiene un valor de tipo lógico (verdadero ofalso). En las expresiones lógicas se pueden utilizar dos tipos de operadores:

Relacionales Lógicos

Un operador relacional se utiliza para comparar los valores de dos expresiones. Éstas deben ser del mismo tipo (aritméticas, lógicas, de carácter o de cadena).

Ejemplo 1: Algunos ejemplos son:

22 > 13 (comparación de dos expresiones aritméticas)22.5 < 3.44 (comparación de dos expresiones aritméticas)verdadero = falso (comparación de dos expresiones lógicas)'c' > 'f' (comparación de dos expresiones de carácter)"coche" = "Coche" (comparación de dos expresiones de cadena)

Proporcionan los valores:

verdadero (22 es mayor que 13)falso (22.5 no es menor que 3.44)falso (verdadero no es igual que falso)falso ('c' no es mayor que 'f')falso ("coche" no es igual que "Coche")

Las comparaciones entre los valores de tipo numérico son obvias. En cuanto a los valores de tipo lógico (verdadero y falso) se considera que falso es menor que verdadero. En lo que respecta a los valores de tipo carácter, su orden viene dado por el ASCII extendido utilizado por el ordenador para representarlos. Y en el caso de los valores de tipo cadena, también se tiene en cuenta dicho código.

Los operadores relacionales son:

Figura - Clasificación de los operadores relacionales en pseudocódigo.

Para escribir una expresión relacional (lógica) se utiliza la sintaxis:

<expresión_1>  <operador_de_relación>  <expresión_2>

Siendo <expresión_1> y <expresión_2> del mismo tipo (aritmética, lógica, de carácter o de cadena).

Por otra parte, un operador lógico actúa, exclusivamente, sobre valores de expresiones lógicas. Los operadores lógicos son:

Figura - Clasificación de los operadores lógicos en pseudocódigo.

El operador conjunción (y) y el operador disyunción (o) siempre actúan sobre dos operandos, mientras que, el operador negación (no) sólo actúa sobre un operando, o dicho de otra forma, es un operador monario. El modo en que actúan los operadores lógicos se resume en las llamadas tablas de verdad, definidas por el matemático George Boole.

La tabla de verdad del operador conjunción (y) es:

Figura - Tabla de verdad del operador conjunción (y) en pseudocódigo.

Se supone que <expresión_1> y <expresión_2> son expresiones lógicas. De la tabla de verdad se deduce que <expresión_1> y <expresión_2> se evalúa a verdadero sólo en el caso de que tanto <expresión_1> como <expresión_2> se evalúen también como verdaderas, en cualquier otro caso el resultado será falso. Dicho de otro modo, si al menos una de las dos expresiones es falsa, el resultado será falso.

Ejemplo 2: Algunos ejemplos son:

9 > 3 y 8 > 69 > 3 y 8 > 99 = 3 y 8 >= 69 = 3 y 8 >= 9

Las expresiones anteriores se evalúan a:

verdadero (9 > 3 es verdadero y 8 > 6 es verdadero)

falso (9 > 3 es verdadero y 8 > 9 es falso)falso (9 = 3 es falso y 8 >= 6 es verdadero)falso (9 = 3 es falso y 8 >= 9 es falso)

La tabla de verdad del operador disyunción (o) es:

Figura - Tabla de verdad del operador disyunción (o) en pseudocódigo.

De la tabla de verdad se deduce que si al menos una de las dos expresiones es verdadera, el resultado será verdadero.

La tabla de verdad del operador negación (no) es:

Figura - Tabla de verdad del operador negación (no) en pseudocódigo.

El valor de no <expresión> es el contrario al valor obtenido de <expresión>.

Ejemplo 3: De las expresiones

no ( 9 > 3 )no ( 8 > 9 )

los resultados de evaluarlas son:

falso (9 > 3 es verdadero)verdadero (8 > 9 es falso)

Operadores de asignación^

Existen varios operadores de asignación, el más evidente y el más usado es el "=", pero en C++ este no es el único que existe.

Aquí hay una lista: "=", "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", " ^=" y "|=". Y la sintaxis es:

<variable> <operador de asignación> <expresión>

En general, para todos los operadores mixtos la expresión:

E1 op= E2

Tiene el mismo efecto que la expresión:

E1 = E1 op E2

El funcionamiento es siempre el mismo, primero se evalúa la expresión de la derecha, se aplica el operador mixto, si existe y se asigna el valor obtenido a la variable de la izquierda.

Los operadores del segundo al sexto son combinaciones del operador de asignación "=" y de los operadores aritméticos que hemos visto en el punto anterior. Tienen las mismas limitaciones que ellos, es decir, el operador "%=" sólo se puede aplicar a expresiones enteras.

El resto de los operadores son operadores de bits, y los veremos más adelante, en otro de los capítulos dedicado a operadores.

Operador coma^

La coma tiene una doble función, por una parte separa elementos de una lista de argumentos de una función. Por otra, puede ser usado como separador en expresiones "de coma". Ambas funciones pueden ser mezcladas, pero hay que añadir paréntesis para resolver las ambigüedades. Sintaxis:

E1, E2, ..., En

En una "expresión de coma", cada operando es evaluado como una expresión, pero los resultados obtenidos anteriormente se tienen en cuenta en las subsiguientes evaluaciones. Por ejemplo:

func(x, (y = 1, y + 2), 7);

Llamará a la función con tres argumentos: (x, 3, 7). La expresión de coma (y = 1, y+2), se evalúa de izquierda a derecha, y el resultado de la última evaluación se pasará como argumento a la función.

Es muy frecuente usar estas expresiones dentro de bucles "for", (que veremos en el próximo capítulo). Por ejemplo:

for(i = 0, j = 1; i < 10; i++) ...

Aquí vemos una expresión de coma que usamos para inicializar dos variables en la zona de inicialización del bucle.

No es aconsejable abusar de las expresiones de coma, aunque sólo sea porque apenas se usan, y suelen despistar a los que interpretan el código.

Por ejemplo, intenta predecir el valor de los parámetros de esta llamada a función:

func(19, (x=0, x+=3, x++), 12);

Si has dicho: 19, 4 y 12, te has equivocado :).

Nota: recuerda que el operador de postincremento se evalúa después de evaluar la sentencia, en este caso, después de la llamada a la función.

Operadores de comparación^

Estos operadores comparan dos operandos, dando como resultado valores booleanos, true (verdadero) o false (falso), dependiendo de si los operandos cumplen o no la operación indicada.

Son "==" (dos signos = seguidos), "!=", "<", ">", "<=" y ">=", que comprueban relaciones de igualdad, desigualdad y comparaciones entre dos valores aritméticos. Sintaxis:

<expresión1> == <expresión2>

<expresión1> != <expresión2>

<expresión1> > <expresión2>

<expresión1> < <expresión2>

<expresión1> <= <expresión2>

<expresión1> >= <expresión2>

Si el resultado de la comparación resulta ser verdadero, se retorna true, en caso contrario false. El significado de cada operador es evidente:

== igualdad

!= desigualdad

> mayor que

< menor que

>= mayor o igual que

<= menor o igual que

En la expresión "E1 <operador> E2", los operandos tienen algunas restricciones, pero de momento nos conformaremos con que E1 y E2 sean de tipo aritmético. El resto de las restricciones las veremos cuando conozcamos los punteros y los objetos.

Expresiones con operadores de igualdad

Cuando se hacen comparaciones entre una constante y una variable, es recomendable poner en primer lugar la constante, por ejemplo:

if(123 == a) ...if(a == 123) ...

Si nos equivocamos al escribir estas expresiones, y ponemos sólo un signo '=', en el primer caso obtendremos un error del compilador, ya que estaremos intentando cambiar el valor de una constante, lo cual no es posible. En el segundo caso, el valor de la variable cambia, y además el resultado de evaluar la expresión no dependerá de una comparación, sino de una asignación, y siempre será true, salvo que el valor asignado sea 0.

Por ejemplo:

if(a = 0) ... // siempre será falseif(a = 123)... // siempre será <b>true</b>, ya que 123 es distinto de 0

El resultado de evaluar la expresión no depende de "a" en ninguno de los dos casos, como puedes ver.

En estos casos, el compilador, en el mejor de los casos, nos dará un "warning", o sea un aviso, pero compilará el programa.

Nota: los compiladores clasifican los errores en dos tipos, dependiendo de lo serios que sean:

"Errores": son errores que impiden que el programa pueda ejecutarse, los programas con "errores" no pueden pasar de la fase de compilación a la de enlazado, que es la fase en que se obtiene el programa ejecutable.

"Warnings": son errores de poca entidad, (según el compilador que, por supuesto, no tiene ni idea de lo que intentamos hacer). Estos errores no impiden pasar a la fase de enlazado, y por lo tanto es posible ejecutarlos. Debes tener cuidado si tu compilador de da una lista de "warnings", eso significa que has cometido algún error, en cualquier caso repasa esta lista e intenta corregir los "warnings".

Operadores aritméticos^

Son usados para crear expresiones matemáticas. Existen dos operadores aritméticos unitarios, '+' y '-' que tienen la siguiente sintaxis:

+ <expresión>

- <expresión>

Asignan valores positivos o negativos a la expresión a la que se aplican.

En cuanto a los operadores binarios existen varios. '+', '-', '*' y '/', tienen un comportamiento análogo en cuanto a los operandos, ya que admiten tanto expresiones enteras, como en coma flotante. Sintaxis:

<expresión> + <expresión>

<expresión> - <expresión>

<expresión> * <expresión>

<expresión> / <expresión>

Evidentemente se trata de las conocidísimas operaciones aritméticas de suma, resta, multiplicación y división, que espero que ya domines a su nivel tradicional, es decir, sobre el papel.

Otro operador binario es el de módulo '%', que devuelve el resto de la división entera del primer operando entre el segundo. Por esta razón no puede ser aplicado a operandos en coma flotante.

<expresión> % <expresión>

Nota: Esto quizás requiera una explicación:

Veamos, por ejemplo, la expresión 17 / 7, es decir 17 dividido entre 7. Cuando aprendimos a dividir, antes de que supiéramos sacar decimales, nos enseñaron que el resultado de esta operación era 2, y el resto 3, es decir 2*7+3 = 17.

En C++, cuando las expresiones que intervienen en una de estas operaciones sean enteras, el resultado también será entero, es decir, si 17 y 7 se almacenan en variables enteras, el resultado será entero, en este caso 2.

Por otro lado si las expresiones son en punto flotante, con decimales, el resultado será en punto flotante, es decir, 2.428571. En este caso: 7*2.428571=16.999997, o sea, que no hay resto, o es muy pequeño.

Por eso mismo, calcular el resto, usando el operador %, sólo tiene sentido si las expresiones implicadas son enteras, ya que en caso contrario se calcularán tantos decimales como permita la precisión de tipo utilizado.

Siguiendo con el ejemplo, la expresión 17 % 7 dará como resultado 3, que es el resto de la división entera de 17 dividido entre 7.

Por último otros dos operadores unitarios. Se trata de operadores un tanto especiales, ya que sólo pueden trabajar sobre variables, pues implican una asignación. Se trata de los operadores '++' y '--'. El primero incrementa el valor del operando y el segundo lo decrementa, ambos en una unidad. Existen dos modalidades, dependiendo de que se use el operador en la forma de prefijo o de sufijo. Sintaxis:

<variable> ++ (post-incremento)

++ <variable> (pre-incremento)

<variable>-- (post-decremento)

-- <variable> (pre-decremento)

En su forma de prefijo, el operador es aplicado antes de que se evalúe el resto de la expresión; en la forma de sufijo, se aplica después de que se evalúe el resto de la expresión. Veamos un ejemplo, en las siguientes expresiones "a" vale 100 y "b" vale 10:

c = a + ++b;

En este primer ejemplo primero se aplica el pre-incremento, y b valdrá 11 a continuación se evalúa la expresión "a+b", que dará como resultado 111, y por último se asignará este valor a c, que valdrá 111.

c = a + b++;

En este segundo ejemplo primero se avalúa la expresión "a+b", que dará como resultado 110, y se asignará este valor a c, que valdrá 110. Finalmente se aplica en post-incremento, y b valdrá 11.

Los operadores unitarios sufijos (post-incremento y post-decremento) se evalúan después de que se han evaluado el resto de las expresiones. En el primer ejemplo primero se evalúa ++b, después a+b y finalmente c =<resultado>. En el segundo ejemplo, primero se evalúa a+b, después c = <resultado> y finalmente b++.

Es muy importante no pensar o resolver las expresiones C como ecuaciones matemáticas, NO SON EXPRESIONES MATEMATICAS. No veas estas expresiones como ecuaciones, NO SON ECUACIONES. Esto es algo que se tarda en comprender al principio, y que después aprendes y dominas hasta el punto que no te das cuenta.

Por ejemplo, piensa en esta expresión:

b = b + 1;

Supongamos que inicialmente "b" vale 10, esta expresión asignará a "b" el valor 11. Veremos el operador "=" más adelante, pero por ahora no lo confundas con una igualdad matemática. En matemáticas la expresión anterior no tiene sentido, en programación sí lo tiene.

Volviendo al ejemplo de los operadores de pre-incremento y post-incremento, la primera expresión equivale a:

b = b+1;

c = a + b;

La segunda expresión equivale a:

c = a + b;

b = b+1;

Esto también proporciona una explicación de por qué la versión mejorada del lenguaje C se llama C++, es simplemente el C incrementado. Y ya que estamos, el lenguaje C se llama así porque las personas que lo desarrollaron crearon dos prototipos de lenguajes de programación con anterioridad a los que llamaron B y BCPL.

4.9.12  Operadores relacionales

§1  Sinopsis

Los operadores relacionales, también denominados operadores binarios lógicos y de comparación, se utilizan para comprobar la veracidad o falsedad de determinadas propuestas de relación (en realidad se trata respuestas a preguntas). Las expresiones que los contienen se denominan expresiones relacionales. Aceptan diversos tipos de argumentos, y el resultado, que es la respuesta a la pregunta, es siempre del tipo cierto/falso, es decir, producen un

resultado booleano (  3.2.1b)

Si la propuesta es cierta, el resultado es true (un valor distinto de cero), si es falsa false (cero). C++ dispone de los siguientes:

<      Menor que

>      Mayor que

<=    Menor o igual que

>=    Mayor o igual que

==    Igual que  (identidad)

!=     Desigual que (desigualdad)

§2  Sintaxis

expresión-relacional  <   shift-expresionexpresión-relacional  >   shift-expresionexpresión-relacional  <=  shift-expresionexpresión-relacional  >=  shift-expresionexpresión-de-igualdad == expresión-relacionalexpresión-de-igualdad != expresión-relacional

§3  Comentario

Como puede verse, todos ellos son operadores binarios (utilizan dos operandos), de los cuales, dos de ellos son de igualdad: == y!=, y sirven para verificar la igualdad o desigualdad entre valores

aritméticos o punteros.  Estos dos operadores pueden comparar ciertos tipos de punteros, mientras que el resto de los operadores relacionales no pueden utilizarse con ellos.

Observe que los operadores == y != tienen una menor precedencia (  4.9.0a) que el resto de los operadores relacionales < y >,<= y >=.

El operador de desigualdad != tiene otra forma estándar de designación mediante la palabra

clave not_eq (  4.9.8)

§3.1    Cualquiera que sea el tipo de los operandos, por definición, un operador relacional, produce un bool (true o false) como resultado, aunque en determinadas circunstancias puede producirse una conversión automática de tipo a valores int (1 si la expresión es cierta y 0 si es falsa).

Ejemplo de comprobación:

#include <iostream.h>

int main() {  float f = 12.1, g = 12.2;  cout << "Tipo: " << typeid(f < g).name() << endl;}

Salida

Tipo: bool

§4  Condiciones

En las expresiones relacionales E1 <operador> E2, los operandos deben cumplir alguna de las condiciones siguientes:

1. E1 y E2 son tipos aritméticos.2. E1 y E2 son punteros a versiones cualificadas o no cualificadas de tipos compatibles.3. Uno de ellos es un puntero a un objeto, mientras que el otro es un puntero a una versión

cualificada o no cualificada devoid.4. Uno de los dos es un puntero, mientras que el otro es un puntero nulo constante.

  Cuando se trata de tipos definidos por el usuario (que no cumplen las condiciones anteriores) estos operadores pueden ser sobrecargados de forma que puedan ser utilizados con dichos tipos (

 4.9.18b1).

§5     Precauciónes !!

§5.1  Con el operador de igualdad

Las expresiones relacionales de igualdad son frecuentísimas en la programación. En multitud de ocasiones se comparan dos expresiones y se toma una decisión en función del resultado cierto /

falso obtenido. Por ejemplo, la condición de la sentencia de iteración while (  4.10.3) puede ser una expresión relacional de igualdad:

int x = 1; y = 2;...while (x == y ) {  cout << "Son iguales..." << endl;  ...}

Es muy frecuente que, tanto el principiante, como el programador acostumbrado a otros lenguajes, donde el operador de asignación y el de igualdad son distintos a los utilizados en C++ (por ejemplo := y =), confundan el operador de igualdad == con el de asignación =. Es este caso, el código anterior sería escrito erróneamente:

while (x = y ) {  cout << "Son iguales..." << endl;  ...}

El resultado es que el bucle se ejecuta mientras sea y != 0, ya que la expresión asigna y a x, y el resultado es cierto mientras que x sea distinto de cero.

Algunos compiladores son suficientemente "inteligentes" como para advertir del posible error, pero otros aceptan que se pretende una asignación. Por ejemplo, en el caso anterior, el compilador Borland C++ 5.5 produce una advertencia:

Possibly incorrect assignment in function....

En cambio Visual C++ 6.0 de MS acepta la propuesta sin rechistar.

§5.2  Con los operadores compuestos

Es frecuente alterar el orden de los operadores compuestos. Recuerde que el signo "=" va a la derecha !!

Ejemplo:

int n = 10;for (i = 0 ; i =< n ; i++) { /* ejecutar este bucle */ }   // Error !!for (i = 0 ; i <= n ; i++) { /* ejecutar este bucle */ }   // Ok.

Acumulador es una variable q almacena informacion en un proceso determinado.. Contador lleva el control de repeticion de un procedimiento .. por ejmplo: 

yo =Falso while(yo = Falso ){ cont = cont + 1 if cont = 3 then yo = true else Acum = Acum + 121 end if } 

en este caso el contador suma de 1 en 1 hasta q sea 3 para darle el valor de Verdadero a (Yo) y salga del bucle. mientras el acumulador Suma 121 + 121 + 121.. hasta q sea 3.. 

ejem:Determinar cuantos numeros pares hay en una cadena de datos de 10 numeros y calcular la suma de numeros pares 

while( i < 11 ) { i = i + 1 N = "Ingrese numero" if n mod 2 = 0 then p = p + 1 S = S + n end if } Aki se Suman los numeros pares en la Variable (s) y En la variable (P) cuenta cuantos numeros pares hay..