Codificación aprenderaprogramar.com: CU00519F
OPERADORES RELACIONALES Y OPERADORES LÓGICOS EN C
Se llaman operadores relacionales o de comparación a aquellos que permiten comparar dos valores evaluando si se relacionan cumpliendo el ser menor uno que otro, mayor uno que otro, igual uno que otro, etc. Los operadores lógicos permiten además introducir nexos entre condiciones como “y se cumple también que” ó . “o se cumple que”.
Los operadores de comparación o relacionales básicos en C son:
Operador | Significado |
Operador < | Menor que |
Operador <= | Menor o igual que |
Operador > | Mayor que |
Operador >= | Mayor o igual que |
Operador == | Igual a |
Operador != | Distinto de ó no igual que |
Es importante tener en cuenta que para comparar si una variable A es igual a otra debemos usar A == B en lugar de A = B. El doble signo igual se usa en comparaciones mientras que el signo igual sencillo se usa en asignaciones.
Para determinar si una variable A tiene distinto contenido que una variable B debemos usar A != B. En C no se admite la sintaxis A <> B que usamos en pseudocódigo.
Suponiendo que la variable A tiene un valor A = 5 y la variable B un valor B = 7 podríamos plantear las siguientes expresiones:
Expresión | Resultado | Ejemplo código |
A == B | 0 (falso) | printf ("A == B vale %d\n", (A == B) ); |
A != B | 1 (verdadero) | printf ("A != B vale %d\n", (A != B) ); |
A > B | 0 (falso) | printf ("A > B vale %d\n", (A > B) ); |
A >= B | 0 (falso) | printf ("A >= B vale %d\n", (A >= B) ); |
A < B | 1 (verdadero) | printf ("A < B vale %d\n", (A < B) ); |
A <= B | 1 (verdadero) | printf ("A <= B vale %d\n", (A <= B) ); |
Hay que tener en cuenta que en C al no tener el tipo booleano entre sus tipos predefinidos el resultado de evaluar estas expresiones es un cero ó un uno, equivaliendo el cero a “falso” y el uno a “verdadero”.
Ejecuta un programa definiendo las variables A y B como de tipo entero, asígnales los valores correspondientes y comprueba las expresiones usando el código de ejemplo que hemos indicado. Define otras variables y haz algunas comprobaciones por tu cuenta.
OPERADORES LÓGICOS EN C
Los operadores lógicos básicos en C son los siguientes:
Operador | Significado |
Operador && | Operador lógico and |
Operador || | Operador lógico or |
Operador ! | Operador lógico not |
Suponiendo que tenemos cuatro variables A, B, C y D cuyos valores se han establecido en A = 5, B = 7, C = 2, D = 5 podríamos evaluar estas expresiones:
Expresión | Pregunta equivalente | Resultado | Ejemplo código |
(A == B) && (A < B) | ¿Es A igual a B y A menor que C? | 0 (falso) | printf ("Pregunta (A == B) && (A < B) vale %d\n", (A == B) && (A < B)); |
(A == 5) || (A > 7) | ¿Es A igual a 5 ó es A mayor que 7? | 1 (verdadero) | printf ("Pregunta (A == 5) || (A > 7) vale %d\n", (A == 5) || (A > 7)); |
! ( A == 5 ) | ¿A es NO igual a 5? | 0 (falso) | printf ("Pregunta ! ( A == 5 ) vale %d\n", ! ( A == 5 )); |
Ejecuta un programa definiendo las cuatro variables A, B, C, D como de tipo entero, asígnales los valores correspondientes y comprueba las expresiones usando el código de ejemplo que hemos indicado. Define otras variables y haz algunas comprobaciones por tu cuenta. Es importante que escribas tu propio código y trates de razonar sobre los resultados esperados y los resultados obtenidos. En muchas ocasiones el resultado obtenido no será el esperado y como programador deberás de ser capaz de determinar el por qué de estas divergencias.
Iremos adquiriendo soltura en el uso de estos operadores cuando realicemos ejercicios usando expresiones condionales.
Ten en cuenta que C tiene un gran número de operadores, de los que aquí solo hemos expuesto los más básicos o habituales.
EJERCICIO
Dadas las variables de tipo entero con valores A = 5, B = 3, C = -12 indicar si la evaluación de estas expresiones daría como resultado verdadero o falso:
a) A > 3 b) A > C c) A < C
d) B < C e) B != C f) A == 3
g) A * B == 15 h) A * B == -30 i) C / B < A
j) C / B == -10 k) C / B == -4 l) A + B + C == 5
m) (A+B == 8) && (A-B == 2) n) (A+B == 8) || (A-B == 6)
o) A > 3 && B > 3 && C < 3 p) A > 3 && B >= 3 && C < -3
https://docs.microsoft.com/es-es/cpp/c-language/c-operators?view=msvc-160
Operadores de C
- Tiempo de lectura: 2 minutos
Los operadores de C son un subconjunto de los operadores integrados de C++.
Hay tres tipos de operadores. Una expresión unaria consta de un operador unario antepuesto a un operando, o la palabra clave sizeof seguida de una expresión. La expresión puede ser el nombre de una variable o una expresión de conversión. Si la expresión es una expresión de conversión, se debe incluir entre paréntesis. Una expresión binaria consta de dos operandos unidos por un operador binario. Una expresión ternaria consta de tres operandos unidos por el operador de expresión condicional.
C incluye los operadores unarios siguientes:
Los operadores binarios se asocian de izquierda a derecha. C proporciona los operadores binarios siguientes:
El operador base( :> ), compatible con las versiones anteriores del compilador de C de 16 bits de Microsoft, se describe en Resumen de la sintaxis de lenguaje C.
El operador de expresión condicional tiene menos prioridad que las expresiones binarias y se diferencia de ellas en que es asociativo a la derecha.
Las expresiones con operadores también incluyen expresiones de asignación, que usan operadores de asignación unarios o binarios. Los operadores de asignación unarios son los operadores de incremento ( ++ ) y decremento ( -- ); los operadores de asignación binarios son el operador de asignación simple ( = ) y los operadores de asignación compuesta. Cada operador de asignación compuesta es una combinación de otro operador binario con el operador de asignación simple.
Vea también
http://cpp.aprende-web.net/basico/basico3/basico3_3.php
3. Operadores
3.3. L�gicos
Definicion
Una operaci�n l�gica utiliza como operandos datos booleanos. La mayor�a de ellas compara dos expresiones o datos booleanos y indica una posibilidad de lo que puede ocurrir cuando se juntan. El resultado es otra expresi�n booleana.
En la p�gina anterior hemos visto las operaciones condicionales, las cuales daban como resultado expresiones booleanas. Por lo tanto tambi�n podemos poner como operandos de las operaciones l�gicas el resultado de una operaci�n condicional. Es decir, cada uno de los operandos es una operaci�n condicional, la cual se realiza en primer lugar, para despu�s realizar las operaci�n l�gica.
Sin embrgo entenderemos esto m�s facilmente cuando veamos cu�les son las operaciones l�gicas.
Operador AND
Esta operaci�n compara dos datos booleanos, de manera que el resultado ser� "true" (verdadero) solamente si los dos operandos son "true" (verdadero); en los dem�s casos el resultado ser� "false" (falso).
El signo para realizar la operacion es && (doble signo ampersand) pero tambi�n podemos poner la palabra and. Por ejemplo, declaramos las siguientes variables booleanas.
bool v1=true, v2=true, f1=false, f2=false, r;
Las variables que tenemos inicializadas las utilizaremos como operandos, mientras que la variable r, sin inicializar, ser� donde obtengamos el resultado, operamos as�:
r = v1 && v2;
El resultado ser� true. La misma operaci�n la podemos escribir as�:
r = v1 and v2;
Aunque es preferible ponerlo como en el primer ejemplo.
Los posibles valores que puede tener el resultado son los siguientes:
r = v1 && v2; // r: true
r = v1 && f1; // r: false
r = f1 && v1; // r: false
r = f1 && f2; // r: false
Aqu� el resultado s�lo es verdadero si los dos operandos son verdaderos.
Operador OR
Este operador compara dos datos booleanos, de manera que el resultado ser� "false" (falso) solamente si los dos operadores son falsos; en los dem�s casos el resultado es "true" (verdadero).
El signo para realizar la operaci�n consiste en la doble barra vertical || (en la mayor�a de los teclados se escribe con las teclas "Alt Gr" + 1). Tambi�n tenemos lam opci�n de escribir la palabra or entre los operandos.
Los posibles valores que puede tener el resultado son los siguientes: (utilizaremos aqu� las mismas variables que en el ejemplo con and)
r = v1 || v2; // r: true
r = v1 || f1; // r: true
r = f1 || v1; // r: true
r = f1 || f2; // r: false
Aqu� el resultado s�lo es falso si los dos operandos son falsos.
Operador NOT
Este es un operador unario, es decir se aplica a un s�lo elemento que ser� un dato booleano, y lo que hace es cambiarlo de valor. De maera que si el dato es verdadero el resultado es falso, y si el dato es falso, el resultado es veradero.
El operando es un signo de admiraci�n puesto delante del dato o variable que contiene el dato. Siguiendo con las mismas variables de ejemplos anteriores.
r = !v1; // r: false
r = !f1; // r: true
Aqu� el resultado siempre es el contrario del que tenemos al principio.
Operador XOR
Este operador compara dos variables booleanas, y devuelve true cuando una de las dos es verdadera true y la otra falsa false. Cuando las dos son verdaderas, o las dos son falsas devuelve false.
El signo del operador es el acento circunflejo ^ , aunque tambi�n podemos escribir la palabra xor entre los dos operandos (El acento circunflejo lo escribimos con may�scula + acento grave, y despu�s la barra espaciadora).
Los posibles valores que puede tener el resultado son los siguientes: (utilizaremos aqu� las mismas variables que en ejemplos anteriores)
r = v1 xor v2; // r: false
r = v1 xor f1; // r: true
r = f1 xor v1; // r: true
r = f1 xor f2; // r: false
Aqu� el resultado es falso cuando los dos operandos son iguales, y verdadero cuando son contrarios.
Operador condicional ternario
Este operador utiliza tres operandos, el primero es siempre un dato o expresi�n booleana. El segundo y el tercero pueden ser datos de cualquier otro tipo, siempre que los dos sean del mismo tipo. Supongamos que declaramos las siguientes variables:
bool tr=true, fs=false;
string vr="verdad", mt="mentira", resultado;
Ahora utilizamos el operador condicional ternario. Lo escribiremos as�:
resultado = tr ? vr : mt;
El primer operando es tr que es un booleano, el segundo y el tercero aqu� son strings, pero pueden ser datos de cualquier otro tipo, siempre que los dos sean del mismo tipo. El resultado ser� el segundo operando siempre que el booleano del primero sea true, y el tercero cuando el booleano sea false. En el ejemplo anterior recogemos el resultado en la variable resultado.
Si seguimos el ejemplo anterior, se puede comprobar mostrando el resultado en pantalla:
cout << resultado << endl;
El resultado al compilar y ejecutar, dar� la palabra "verdad". Si cambiamos el primer operando (variable tr) por la variable fs, veremos que el resultado es la palabra "mentira".
Programa con operadores l�gicos
Vamos a hacer un programa en el que vemos c�mo funcionan los operadores l�gicos. El programa es el siguiente:
#include<iostream>
using namespace std;
int main() {
bool p, s;
cout << "OPERADORES LOGICOS" << endl;
cout << "Escribe un primer booleano ( 0 - 1) : ";
cin >> p;
cout << "Escribe un segundo booleano ( 0 - 1) : ";
cin >> s;
cout << "Tus operandos : p = " << p << " : s = " << s << endl;
cout << "OPERACIONES : " << endl << endl;
cout << p << " and " << s << " : " << (p and s) << endl;
cout << p << " or " << s << " : " << (p or s) << endl;
cout << p << " xor " << s << " : " << (p xor s) << endl;
cout << "NOT_primero : " << !p << endl;
cout << "NOT_segundo : " << !s << endl;
string v="Verdadero", f="falso";
cout << "Primer operando : " << (p?v:f) << endl;
cout << "Segundo operando : " << (s?v:f) << endl;
}
Al compilar y ejecutar el programa, �ste se abre y pide al usuario que introduzca dos booleanos. �ste escribe los booleanos en forma de 0 � 1, y despu�s se realizan las operaciones l�gicas con los mismos.
Observa en el c�digo fuente c�mo realizamos las operaciones "and", "or", "xor" y "not", y luego utilizamos el operador condicional ternario para indicar si los operandos son verdaderos o falsos.
El uso de par�ntesis es necesario para delimitar las operaciones, de manera que as� se indica que �sta es un todo del cual se debe mostrar el resultado.
En la siguiente p�gina seguimos viendo los operadores l�gicos y su relacion con los operadores condicionales.
https://sites.google.com/site/cparaprincipiantes/operadores-logicos
5. Operadores
Un operador es un símbolo que permite relacionar dos datos en una expresión y evaluar el resultado de la operación. Los programas de las computadoras se apoyan esencialmente en la realización de numerosas operaciones aritméticas y matemáticas de diferente complejidad. Los operadores fundamentales son: • Aritméticos. • Relaciónales. • Lógicos. • Asignación. Operadores aritméticos Los operadores aritméticos de la tabla II.3 * ,/, ++,--) pueden ser utilizados con tipos enteros o reales y sirven para realizar operaciones aritméticas básicas. Por ejemplo si a = 15 y b = 3, vemos los resultados de los diferentes operadores aritméticos. Tabla de Operadores aritméticos  El operador % en lenguaje C, como se mencionó, calcula el residuo que queda al dividir dos números enteros; el siguiente programa muestra lo que realiza ese operador: #linclude <stdio.h> #include <conio.h> main( ) { int x=7,y=2; printf("%d",x%y); } En la pantalla aparecerá: 1 Ya que la división de 7/2 es 3 y el residuo es 1 Incremento y decremento
Operadores relaciónales Describen una relación entre dos valores; por lo tanto, se usan para expresar condiciones y para comparar dos valores. El resultado de una expresión relacional es un valor tipo lógico, sólo puede ser verdadero o falso. El lenguaje C representa como verdadero el valor 1 y como falso el valor 0. En la tabla II.5 se muestran los operadores relaciónales y en la tabla II.6 ejemplos de los mismos. Tabla de Operadores relaciónales Operador
Ejemplos de operadores relaciónales  Otro ejemplo: x+y< =3*z La expresión anterior compara el valor de la suma de* y y con el triple del valor de z; si la suma es menor o igual que el triple de z entonces el resultado de la expresión es 1, y en el caso contrario es 0. Operadores lógicos Las expresiones lógicas pueden combinarse para formar expresiones más complejas utilizando los operadores lógicos. En la tabla II.7 se muestran dichos operadores y en la tabla II.8 ejemplos. Estos operadores se utilizan con constantes lógicas de forma similar al modo en que los operadores aritméticos se utilizan con las constantes numéricas; estos operadores trabajan con operandos que son expresiones lógicas: [condición] operador: [condición] Tabla de Operadores lógicos Pseudocódigo Lenguaje C  Como se muestra en tabla anterior, se pueden evaluar una o más condiciones en una expresión, y siempre el resultado es un único valor lógico. Para la evaluación de expresiones lógicas es importante conocer la tabla de verdad. Tabla de verdad
Otros ejemplos en lenguaje C: La expresión !(4> 1) al evaluarla el resultado que da es 0. La expresión: a=!(4>l) almacena 0 en la variable a, debido a que la expresión 4>1 es verdadera y el operador / niega la expresión haciéndola falsa o igual a cero. Operadores de asignación El operador de asignación permite evaluar una expresión y asignar el resultado de la asignación en una variable. Su sintaxis es: Lenguaje C Identificador = expresión; Con la asignación anterior le estaremos indicando a la computadora que: evalúe la expresión y la almacene en la variable que se identifica por el identificador. Estos operadores permiten transferir el dato de una variable a otra. Así, la expresión x=a en lenguaje C transfiere el valor de “a” a la variable*. En la tabla 11.10 se muestran ejemplos de operadores de asignación. Nunca debe escribirse la expresión a la izquierda del operador de asignación: Lenguaje C (cali + cal2) = promedio; Ejemplos de operadores de asignación.
Otros operadores de asignación en C En la tabla siguiente vemos otros operadores de asignación propios de lenguaje C: +=, *=, =, /= y %=, donde la sintaxis cuando se quiere utilizar uno de esos operadores es: Identificador operador_asignación expresión; Tabla Otros operadores de asignación en C Operador Ejemplo Equivalencia += c += 11 c = c +11 -= d -= 16 d = d -16 *= e=4 e = e* 4 /= 11=2 f = f / 2 %= x %= 33 x = x % 33 Fuente: elaboración propia. Prioridad de los operadores Al orden en que la computadora realiza las diferentes operaciones le llamamos orden de prioridad. Operadores aritméticos: 1. Paréntesis ( ). Todas las expresiones entre paréntesis se evalúan primero. Las expresiones con paréntesis anidados se evalúan de dentro hacia afuera; el paréntesis más interno se evalúa primero. 2. Prioridad de operaciones. Dentro de una misma expresión o subexpresión, los operadores se evalúan en el siguiente orden: * , / ,mod primero +, - último 3. Regla asociativa izquierda. Los operadores en una misma expresión con igual nivel de prioridad (tal como * y /) se evalúan de izquierda a derecha. Operadores lógicos 1.-! (Negación) 2.- && (y) 3.- 11 (ó) En la tabla siguiente apreciamos la prioridad de todos los operadores en lenguaje C. Prioridad de los operadores en C. Los operadores de asignación tienen menor prioridad que todos los otros operadores. Por tanto las operaciones monanos, aritméticos, de relación, de igualdad y lógicos se realizan antes que las de asignación. El orden de las operaciones en pseudocódigo es: Expresiones Una expresión es el resultado de unir operandos mediante operadores. Los operandos pueder ser variables, constantes u otras expresiones; y los operadores, aritméticos, lógicos o relacionóles. El resultado de una expresión es un dato numérico o un valor lógico. Según sea el tipo de datos que manipulan, se clasifican las expresiones en. • Aritméticas. • Relaciónales. • Lógicas. Escritura de fórmulas matemáticas Las fórmulas matemáticas se deben escribir en formato lineal. Esto obliga al uso frecuente _c paréntesis que indiquen el orden de evaluación correcto de los operadores.  |
https://ejercicioscpp.blogspot.com/2012/11/operadores-c.html
Operadores C++
Expresión | Valor | Expresión | Valor | Expresión | Valor |
a+b | 13 | v1+v2 | 14.5 | c1 | 80 |
a-b | 7 | v1-v2 | 10.5 | c1 + c2 | 164 |
a*b | 30 | v1*v2 | 25.0 | c1 + c2 + 5 | 169 |
a/b | 3 | v1/v2 | 6.25 | c1 + c2 + ‘5’ | 217 |
a%b | 1 |
Expresión | Valor | Tipo |
i + f | 12.5 | double |
i + c | 126 | int |
i + c – ‘0’ | 78 | int |
(i + c) – (2 * f / 5) | 123.8 | double |
Expresión | Resultado |
(i >= 6) && (c == ‘w’) | Cierto |
(i >= 6) || (c == 119) | Cierto |
(f < 11) and (i > 100) | Falso |
(c != ‘p’) or ((i + f) <= 10) | Cierto |
i + f <= 10 | Falso |
i >= 6 && c == ‘w’ | Cierto |
c != ‘p’ || i + f <= 10 | Cierto |
Operadores de asignación.
Expresión | Expresión equivalente | Valor final |
i += 5 | i = i + 5 | 10 |
f –= g | f = f – g | 8.75 |
j *= (i – 3) | j = j * (i – 3) | 14 |
f /= 3 | f = f / 3 | 1.833333 |
i %= (j - 2) | i = i % (j – 2) | 0 |
x *= -2 * (y + z) / 3 | x = x * (-2 * (y + z) / 3) | -4 |
Dan como resultado:
Prioridad y orden de evaluación de los operadores en C++
:: | Sin asociatividad |
() [] . -> n++ n-- _cast typeid | Izquierda a Derecha |
signo ~ ! * & ++n -–n sizeof new delete (tipo) | Derecha a Izquierda |
->* .* | Izquierda a Derecha |
* / % | Izquierda a Derecha |
+ - | Izquierda a Derecha |
<< >> | Izquierda a Derecha |
< <= > >= | Izquierda a Derecha |
== != | Izquierda a Derecha |
& | Izquierda a Derecha |
^ | Izquierda a Derecha |
| | Izquierda a Derecha |
&& | Izquierda a Derecha |
| | | Izquierda a Derecha |
? : | Derecha a Izquierda |
= += -= *= /= %= <<= >>= &= |= ^= | Derecha a Izquierda |
, | Izquierda a Derecha |
http://lsi.vc.ehu.es/pablogn/docencia/FdI/FdIc/labs/a1/htm/oper.html
Operadores en C
Operadores de asignación
La operación más importante en cualquier lenguaje de programación es la asignación:
En C hay muchos operadores de asignación que serán en realidad simplificaciones de expresiones más complejas, como las auto-operaciones (+=, -=, *=, /=, &=, ...) y los pre/post incrementos/decrementos (++, --).
En general estas expresiones no podrán ser utilizadas en los diagramas de flujo.
Operadores aritméticos
Cabe destacar que se diferencian la división entera y la división real, según los operandos.
Operadores relacionales
Operadores lógicos
Los operandos son considerados falsos (valor 0) ó ciertos (valor distinto de 0). El resultado siempre es 0 ó 1.
Para estudiar el resultado se utilizan las tablas de verdad.
Operadores bit a bit
Afectan a los operandos bit a bit, por lo que se aplica la operación lógica a cada uno de ellos. El resultado bit a bit es 0 ó 1 pero la composición de estos resultados no tiene porqué ser 0 ó 1, como era el caso en los operadores lógicos.
Las tablas de verdad, aplicadas bit a bit a los operandos, son:
Operador condicional
Es un operador ternario, es decir, tiene tres operandos.
Su funcionamiento es el siguiente: para una ejecución c ? e1 : e2 siendo c, e1 y e2 tres expresiones,
Se evalúa c
Si el resultado es cierto (es decir, distinto de cero)
se evalúa e1 y éste sera el resultado.
Si no (el resultado es falso o cero)
se evalúa e2 y éste sera el resultado.
Ejemplos. Para x = 4, y = 2, z = 7:
La expresión x >= 5? 1:0 se evalúa a 1
La expresión x >= 5? y:z se evalúa a 7
La expresión x <= 5? y:z se evalúa a 2
La expresión x ? z+y:z-y se evalúa a 9
La expresión x >= 0 ? sqrt(x):0 se evalúa a 2.0 (sqrt: raíz cuadrada, prototipo en math.h)
Precedencia y asociatividad
Atrás
https://naps.com.mx/blog/instrucciones-condicionales-ejemplos-en-c/
Instrucciones condicionales: Ejemplos en C
Feb 23,2017 ¿Dudas? Por Gibrán García C.
Una de las características de un lenguaje de programación es el uso de instrucciones condicionales. Veamos diferentes tipos de instrucciones condicionales a través de ejemplos en lenguaje C.
Aprende mas sobre instrucciones condicionales
Instrucciones condicionales
Sentencia if…else
La utilizamos cuando tenemos una condición que nos arroja dos resultados: Verdadero o Falso.
Por ejemplo: Escribir un programa en C que lea una edad e indique si la persona puede votar o no.
La instrucción if abre un paréntesis que dentro lleva una condición: edad >= 18. No lleva punto y coma. Si colocaras el punto y coma, el error lo encontraría hasta la sentencia else.
Justo después de la condición que está entre paréntesis, se abre una llave {, todo lo que siga a partir de aquí y hasta que se cierre la llave, son las instrucciones que se ejecutarán si la condición es verdadera.
Después del cierre de la llave } , encontramos la sentencia else, que no lleva condición. Else abre una llave y todo lo que siga a partir de esta llave y hasta su cierre }, son las instrucciones que se ejecutarán si la condición es falsa.
Operadores condicionales
Las condiciones que van dentro de los paréntesis usan operadores condicionales, que son los siguientes: <, >, <=, >=, ==, !=. (Menor, mayor, menor-igual, mayor-igual, igual, diferente)
En el siguiente ejemplo utilizamos una instrucción if…else y un operador menor-igual <=
Ejemplo: Realizar programa que utilice un saldo lea un deposito, agrege el deposito al saldo, lea un retiro, verifique que hay suficiente saldo. Si hay suficiente saldo, realiza la operacion.
Ifs anidados
Los if pueden contener cualquier tipo de instrucción, incluidos otros if.
En el siguiente ejemplo utilizaremos dos if. Uno va dentro de la parte del else (cuando da falso la condición).
Consiste en identificar cuando un número es nulo, positivo o negativo.
El primer if utiliza un operador igual == para determinar si el número es cero. (Tiene que escribir ==, si escribe un solo signo = está indicando una operación de asignación, no de comparación).
Cuando no es cero (la parte else) quiere decir que es positivo o negativo. Para saber si es positivo o negativo usamos otro if. En este segundo if solo tenemos que preguntar si es menor que cero (n<0), la parte else por lógica indica que el número es positivo.
Operadores lógicos
Los operadores lógicos son Y, O, y NO (AND, OR y NOT). En lenguaje C se utilizan estos símbolos: &&, || y !
Se utilizan para que evaluar dos o más condiciones en un solo if.
Vea el siguiente ejemplo:
Hacer un programa que realice descuentos en base a lo siguiente:
Si la compra es menor a 500 no hay descuento
Si es entre 500 y 1000, 10% de descuento
Si es entre 1000 y 2000, 20% de descuento
Si es mayor a 2000, 30% de descuento
Usamos 4 if, uno por cada descuento del programa. Estos if no utilizan la sentencia else, por lo que se evalúan siempre los 4.
El segundo if utiliza el operador lógico && (and), para unir dos condiciones: ¿compra es mayor-igual a 500 Y compra es menor que 1000?
Si el usuario introdujera en compra el valor de 800, el if cumple las dos condiciones (es mayor-igual a 500 y al mismo tiempo menor que 1000), por lo que se ejecutarían las instrucciones que están entre sus llaves. De lo contrario continúa en la siguiente línea después del cierre de la llave }
El tercer if hace algo parecido.
Operador AND
Tabla de verdad
V && V = V
V && F = F
F&& V =F
F && F= F
Si el usuario introdujera el valor de compra de 1200, y la instrucción fuese:
if (compra >= 500 && compra < 1000)
la primera condición sí da verdadero (compra es mayor que 500), pero la segunda da falso (compra no es menor que 1000), por lo que la sentencia completa da falso y no se ejecutaría la sección de código correspondiente.
Comparación de cadenas en C
En los ejemplos anteriores hemos utilizado comparación de números. Si deseamos utilizar cadenas de caracteres, necesitamos algunas instrucciones adicionales.
Vea el siguiente ejemplo:
Cree un programa que lea una clave.
Si la clave es itsa es correcta, si no, es incorrecta.
Utilizamos una nueva biblioteca llamada string.h. También utilizamos la instrucción strcmp que nos sirve para comparar cadenas. Se utiliza así
if (strcmp(clave, “itsa”)==0){
se escribe strcmp y entre paréntesis se anotan las dos cadenas que deseamos comprar, en este ejemplo, la clave que el usuario introdujo y la cadena “itsa”; si el resultado de esta comparación es 0, quiere decir que no hay diferencias.
Operador OR ||
Supongamos que deseamos utilizar dos claves distintas. La instrucción completa quedaría así
if (strcmp(clave, “itsa”)==0 || strcmp(clave,”1234”)==0{
Observe que utilizamos el operador lógico or ||, que evalúa dos condiciones. El operador or nos permite que con que una sola de las dos instrucciones de verdadero, la sentencia completa se evalúa como verdadera.
Tabla de verdad
V || V = V
V || F = V
F || V = V
F || F = F
Si el usuario escribe como clave 1234, la primera condición se evalúa a falso, pues clave no es igual a “itsa”, pero la segunda condición sí se evalúa a verdadero, porque clave es igual a 1234, por lo que toda la condición es verdadera y se ejecutan las instrucciones que siguen a la llave.
https://www.geeksforgeeks.org/operators-c-c/
Operators in C / C++
Difficulty Level : Easy
Last Updated : 17 Feb, 2021
Operators are the foundation of any programming language. Thus the functionality of C/C++ programming language is incomplete without the use of operators. We can define operators as symbols that help us to perform specific mathematical and logical computations on operands. In other words, we can say that an operator operates the operands.
For example, consider the below statement:
c = a + b;
Here, ‘+’ is the operator known as addition operator and ‘a’ and ‘b’ are operands. The addition operator tells the compiler to add both of the operands ‘a’ and ‘b’.
C/C++ has many built-in operator types and they are classified as follows:
Arithmetic Operators: These are the operators used to perform arithmetic/mathematical operations on operands. Examples: (+, -, *, /, %,++,–). Arithmetic operator are of two types:
Unary Operators: Operators that operates or works with a single operand are unary operators. For example: (++ , –)
Binary Operators: Operators that operates or works with two operands are binary operators. For example: (+ , – , * , /)
To learn Arithmetic Operators in details visit this link.
Relational Operators: These are used for comparison of the values of two operands. For example, checking if one operand is equal to the other operand or not, an operand is greater than the other operand or not etc. Some of the relational operators are (==, >= , <= ). To learn about each of these operators in details go to this link.
Logical Operators: Logical Operators are used to combine two or more conditions/constraints or to complement the evaluation of the original condition in consideration. The result of the operation of a logical operator is a boolean value either true or false. For example, the logical AND represented as ‘&&’ operator in C or C++ returns true when both the conditions under consideration are satisfied. Otherwise it returns false. Therfore, a && b returns true when both a and b are true (i.e. non-zero). To learn about different logical operators in details please visit this link.
Bitwise Operators: The Bitwise operators is used to perform bit-level operations on the operands. The operators are first converted to bit-level and then the calculation is performed on the operands. The mathematical operations such as addition, subtraction, multiplication etc. can be performed at bit-level for faster processing. For example, the bitwise AND represented as & operator in C or C++ takes two numbers as operands and does AND on every bit of two numbers. The result of AND is 1 only if both bits are 1. To learn bitwise operators in details, visit this link.
Assignment Operators: Assignment operators are used to assign value to a variable. The left side operand of the assignment operator is a variable and right side operand of the assignment operator is a value. The value on the right side must be of the same data-type of variable on the left side otherwise the compiler will raise an error.
Different types of assignment operators are shown below:
“=”: This is the simplest assignment operator. This operator is used to assign the value on the right to the variable on the left.
For example:
a = 10;
b = 20;
ch = 'y';
“+=”: This operator is combination of ‘+’ and ‘=’ operators. This operator first adds the current value of the variable on left to the value on right and then assigns the result to the variable on the left.
Example:
(a += b) can be written as (a = a + b)
If initially value stored in a is 5. Then (a += 6) = 11.
“-=”: This operator is combination of ‘-‘ and ‘=’ operators. This operator first subtracts the value on right from the current value of the variable on left and then assigns the result to the variable on the left.
Example:
(a -= b) can be written as (a = a - b)
If initially value stored in a is 8. Then (a -= 6) = 2.
“*=”: This operator is combination of ‘*’ and ‘=’ operators. This operator first multiplies the current value of the variable on left to the value on right and then assigns the result to the variable on the left.
Example:
(a *= b) can be written as (a = a * b)
If initially value stored in a is 5. Then (a *= 6) = 30.
“/=”: This operator is combination of ‘/’ and ‘=’ operators. This operator first divides the current value of the variable on left by the value on right and then assigns the result to the variable on the left.
Example:
(a /= b) can be written as (a = a / b)
If initially value stored in a is 6. Then (a /= 2) = 3.
Other Operators: Apart from the above operators there are some other operators available in C or C++ used to perform some specific task. Some of them are discussed here:
sizeof operator: sizeof is a much used in the C/C++ programming language. It is a compile time unary operator which can be used to compute the size of its operand. The result of sizeof is of unsigned integral type which is usually denoted by size_t. Basically, sizeof operator is used to compute the size of the variable. To learn about sizeof operator in details you may visit this link.
Comma Operator: The comma operator (represented by the token ,) is a binary operator that evaluates its first operand and discards the result, it then evaluates the second operand and returns this value (and type). The comma operator has the lowest precedence of any C operator. Comma acts as both operator and separator. To learn about comma in details visit this link.
Conditional Operator: Conditional operator is of the form Expression1 ? Expression2 : Expression3 . Here, Expression1 is the condition to be evaluated. If the condition(Expression1) is True then we will execute and return the result of Expression2 otherwise if the condition(Expression1) is false then we will execute and return the result of Expression3. We may replace the use of if..else statements by conditional operators. To learn about conditional operators in details, visit this link.
Operator precedence chart
The below table describes the precedence order and associativity of operators in C / C++ . Precedence of operator decreases from top to bottom.
https://www.geeksforgeeks.org/operators-in-c-set-1-arithmetic-operators/
Operators in C | Set 1 (Arithmetic Operators)
Difficulty Level : Easy
Last Updated : 18 Nov, 2020
Operators are the foundation of any programming language. Thus the functionality of C language is incomplete without the use of operators. Operators allow us to perform different kinds of operations on operands. In C, operators in Can be categorized in following categories:
Arithmetic Operators (+, -, *, /, %, post-increment, pre-increment, post-decrement, pre-decrement)
Relational Operators (==, !=, >, <, >= & <=) Logical Operators (&&, || and !)
Bitwise Operators (&, |, ^, ~, >> and <<)
Assignment Operators (=, +=, -=, *=, etc)
Other Operators (conditional, comma, sizeof, address, redirection)
Arithmetic Operators: These are used to perform arithmetic/mathematical operations on operands. The binary operators falling in this category are:
Addition: The ‘+’ operator adds two operands. For example, x+y.
Subtraction: The ‘-‘ operator subtracts two operands. For example, x-y.
Multiplication: The ‘*’ operator multiplies two operands. For example, x*y.
Division: The ‘/’ operator divides the first operand by the second. For example, x/y.
Modulus: The ‘%’ operator returns the remainder when first operand is divided by the second. For example, x%y.
C
C++
Output:
a is 10 and b is: 4
a+b is: 14
a-b is: 6
a*b is: 40
a/b is: 2
a%b is: 2
The ones falling into the category of unary arithmetic operators are:
Increment: The ‘++’ operator is used to increment the value of an integer. When placed before the variable name (also called pre-increment operator), its value is incremented instantly. For example, ++x.
And when it is placed after the variable name (also called post-increment operator), its value is preserved temporarily until the execution of this statement and it gets updated before the execution of the next statement. For example, x++.Decrement: The ‘ – – ‘ operator is used to decrement the value of an integer. When placed before the variable name (also called pre-decrement operator), its value is decremented instantly. For example, – – x.
And when it is placed after the variable name (also called post-decrement operator), its value is preserved temporarily until the execution of this statement and it gets updated before the execution of the next statement. For example, x – –.
C
C++
Output:
a is 11 and res is 10
a is 10 and res is 11
a is 11 and res is 11
a is 10 and res is 10
We will soon be discussing other categories of operators in different posts.
To know about Operator Precedence and Associativity, refer this link:
This article is contributed by Ayush Jaggi. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
