martes, 23 de marzo de 2021

Operadores y Expresiones en Lenguaje C

 



https://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=908:operadores-logicos-y-relacionales-en-lenguaje-c-igual-que-distinto-and-aa-or-not-ejemplos-cu00519f&catid=82&Itemid=210

Operadores lógicos y relacionales en lenguaje C. Igual que, distinto, and &&, or ||, not ! Ejemplos. (CU00519F)

Resumen: Entrega nº19 del tutorial "Curso básico de programación en lenguaje C desde cero".
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”.

logo lenguaje programacion C

 

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

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:

TABLA 1
SímboloNOMBRE
- ~ !Operadores de negación y complemento
* &Operadores de direccionamiento indirecto y address-of
sizeofOperador de tamaño
+Operador unario más
++ --Operadores unarios de incremento y decremento

Los operadores binarios se asocian de izquierda a derecha. C proporciona los operadores binarios siguientes:

TABLA 2
SímboloNOMBRE
* / %Operadores de multiplicación
+ -Operadores aditivos
<< >>Operadores de desplazamiento
< > <= >= == !=Operadores relacionales
& | ^Operadores bit a bit
&& ||Operadores lógicos
,Operador de evaluación secuencial

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

Logo C++ Basico

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:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
#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;
}


operaciones logicas

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.

Condicionales y l�gicos



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
 ++ ++¡ Se incrementa / en 1 ya continuación se utiliza el nuevo valor de i en la expresión en la cual resida i
 ++ ¡++ Utiliza el valor actual de i en la expresión en la cual reside /', y después se incrementa a en 1
 -- --¡ Se decrementa / en 1 y a continuación se utiliza el nuevo valor de /'en la expresión en la cual reside i
 -- ¡-- Se utiliza el valor actual de / en la expresión en la cual reside /', y después se decrementa a / en 1

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
 Pseudocódigo Lenguaje C Significado
 >> Mayor que
 < Menor que
 ===  Igual que
 >=>=  Mayor 0 igual que
 <=<=  Menor 0 igual que
 <>!=  Distinto a


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
 p Q !Q  P&&Q P\\Q
 verdad verdad falso  verdad verdad
verdad  falso  verdad falso  verdad
 falso  verdad falso  falso  verdad
 falso  falso  verdad falso  falso 


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.

 Pseudocódigo Lenguaje C Significado
 c <— c + 7 c = c + 7 Incrementa 7 a la variable c
 x <— d — 4 x = d - 4 Almacena en x la diferencia de d menos 4
 j e * 5  j = e * 5 Almacena en j el producto de e por 5
 f <— f / 3    f = f / 3 Divide el valor de f entre 3 y lo almacena en la variable f
 g <— g mod 9 g = g % 9 Divide el valor de g entre 9 y almacena el residuo en la variable g

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++

Operadores aritméticos.
+                 Suma
-                  Resta
*                 Multiplicación
/                 División
%                Módulo ó resto de la división entera
En C++ no hay operador de potenciación. Esta operación se realiza con la función pow.
El operador % obtiene el resto de la división entre enteros. Requiere que los operandos sean enteros y el segundo operando no sea nulo. Cuando se aplica el operador % a operandos de distinto signo, la mayoría de las versiones de C++ asignan al resultado el signo del primer operando.
El operador / requiere que el segundo operando no sea nulo. Si los dos operandos son enteros se obtiene como resultado la parte entera (cociente truncado, sin decimales).
Ejemplo de operaciones:
int a = 10, b = 3;
double v1 = 12.5, v2 = 2.0;
char c1='P', c2='T'; //Según la tabla ASCII ‘P’=80 ‘T’=84 ‘5’=53
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




En aquellas expresiones en las que aparecen operandos de distinto tipo, C++ convierte los valores al tipo de dato de mayor precisión de todos los datos que intervienen. Esta conversión es de forma temporal, solamente para realizar la operación. Los tipos de datos originales permanecen igual después de la operación.
Por ejemplo:
int n = 10;
double v1 = 12.5, v2;
v2 = n + v1;  // da como resultado 22.5
para realizar esta operación se convierte el valor de n a tipo double que es el tipo de v1. Realmente n no se modifica, solo su valor es convertido para realizar la suma.
Más ejemplos:
int i = 7;
double f = 5.5;
char c = 'w';  // ASCII ‘w’=119 ‘0’=48

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
En ocasiones resulta útil convertir el valor de una expresión a un tipo de datos diferente: esto se conoce como casting o conversión de tipos que veremos más adelante.
En las expresiones en las que aparecen varios operadores aritméticos, el orden de ejecución es siempre de mayor a menor prioridad y dentro de la misma prioridad de izquierda a derecha. Los operadores *, / y % tienen entre ellos la misma prioridad, siendo mayor que la de + y –, que también tienen entre ellos la misma prioridad. (Ver tabla al final de la entrada)
Operadores unitarios.
–        +                signos negativo y positivo
++    --                 incremento  y decremento
~ ó compl             Complemento a 1    
Estos operadores afectan a un solo operando.
El operador incremento ++ incrementa en 1 el valor de la variable.
Ejemplo:
int i = 1;
i++;   // Esta instrucción incrementa en 1 la variable i.
         // Es lo mismo que hacer i = i + 1; i toma el valor 2
El operador decremento –- decrementa en 1 el valor de la variable.
Ejemplo:
int i = 1;
i--;    // decrementa en 1 la variable i. 
        // Es lo mismo que hacer i = i - 1; i toma el valor 0
Los operadores incremento y decremento pueden utilizarse como prefijo o sufijo, es decir, pueden aparecer antes o después de la variable.
Por ejemplo:
i = 5;
i++; // i vale ahora 6
++i; // i vale ahora 7
Cuando estos operadores intervienen en una expresión, si preceden al operando (++i), el valor se modificará antes de que se evalúe la expresión a la que pertenece.
En cambio, si el operador sigue al operando (i++), entonces el valor del operando se modificará después de evaluar la expresión a la que pertenece.
Por ejemplo:
int x, i = 3;
x = i++;
En esta asignación a x se le asigna el valor 3 y a continuación i se incrementa, por lo tanto, después de ejecutarla: x contiene 3, i contiene 4.
Si las instrucciones son:
int x, i = 3;
x = ++i;
En esta instrucción primero se incrementa i y el resultado se asigna a x. Por lo tanto, después de ejecutarla: x contiene 4, i contiene 4.

Otro ejemplo:
int i = 1;
cout << i << “ “;
cout << ++i << “ “;
cout << i << “ “;
Estas instrucciones mostrarán por pantalla:
1 2 2
En cambio, si se cambia la posición del operador:
int i = 1;
cout << i << endl;
cout << i++ << endl;
cout << i << endl;
Estas instrucciones mostrarán por pantalla:
1
1
2
El operador complemento a 1 ~ cambia de valor todos los bits del operando (cambia unos por ceros y ceros por unos). Solo puede usarse con datos de tipo entero.
Puede usarse el carácter ~ (ASCII 126) ó el operador equivalente compl.
Por ejemplo:
int a = 1, b = 0, c = 0;
c = ~a;
b = compl a;
Operadores relacionales y lógicos.
Los operadores relacionales comparan dos operandos y dan como resultado de la comparación verdadero  ó falso.
Los operadores relacionales en C++ son:
<                          Menor que
>                          Mayor que
<=                        Menor o igual
>=                        Mayor o igual
!= ó not_eq            Distinto
==                        Igual
Los operadores lógicos se utilizan con operandos de tipo lógico y dan como resultado verdadero o falso.
Los operadores lógicos en C++ son: 
&& ó and     El resultado es verdadero si los dos operandos son verdaderos. El resultado el falso en caso contrario. Si el primer operando es falso no se evalúa el segundo, ya que el resultado será falso.
|| ó or       El resultado es falso si los dos operandos son falsos. Si uno es verdadero el resultado es verdadero. Si el primer operando es verdadero no se evalúa el segundo.
! ó not        Se aplica sobre un solo operando. Cambia el valor del operando de verdadero a falso y viceversa.

Los operadores relacionales se utilizan para construir expresiones lógicas, cuyo resultado es de tipo cierto o falso.
En C++ toda expresión numérica con un valor distinto de cero (no sólo el 1) se considera como cierta y el valor cero como falsa.
Por ejemplo, en la siguiente tabla vemos una serie de expresiones lógicas y su valor:
int i = 7;
float f = 5.5F;
char c = ‘w’;
         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

Las expresiones lógicas compuestas que constan de expresiones lógicas individuales unidas por los operadores lógicos && y || se evalúan sólo hasta que se ha establecido el valor cierto o falso del conjunto.
Cuando, por ejemplo, una expresión va a ser seguro falsa por el valor que ha tomado uno de sus operandos, C++ ya no evalúa el resto de expresión.
Operadores a nivel de bits
Operan con datos de tipo entero. Realizan con sus operandos las operaciones lógicas and, or, xor y desplazamiento bit a bit.
Los operadores a nivel de bits en C++ son:
& ó bitand     and a nivel de bits
| ó bitor        or a nivel de bits
^ ó xor         xor a nivel de bits
<<               desplazamiento a la izquierda, rellenando con ceros a la derecha
>>             desplazamiento a la derecha, rellenando con el bit de signo por la izquierda
Por ejemplo:
int a = 11, b = 7, c;
c = a & b;      // 11 & 7, en binario: 1011 and 0111 = 0011 que es el 3 en decimal
cout << c << endl;   // muestra 3 
c = a | b;
cout << c << endl;   // muestra 15
c = a ^ b;
cout << c << endl;   // muestra 12
c = b << 1;
cout << c << endl;   // muestra 14. Equivale a b * 2
c = b >> 1;
cout << c << endl;   // muestra 3. Equivale a 3 / 2

Operadores de asignación.
Se utilizan para asignar el valor de una expresión a una variable.
=                          Asignación
+=                       Suma y asignación
– =                       Resta y asignación
*=                        Producto y asignación
/=                        División y asignación
%=                       Resto de la división entera y asignación
<<=                      Desplazamiento a la izquierda y asignación
>>=                      Desplazamiento a la derecha y asignación
&= ó and_eq           and sobre bits y asignación
|= ó or_eq             or sobre bits y asignación
^= ó xor_eq           xor sobre bits y asignación
Si los dos operandos de una expresión de asignación son de distinto tipo, el valor de la expresión de la derecha se convertirá al tipo del operando de la izquierda.
Por ejemplo, una expresión de tipo real (float, double) se truncará si se asigna a un entero, o una expresión de tipo double se redondeará si se asigna a una variable de tipo float.
En C++ están permitidas las asignaciones múltiples.
Ejemplo:       a = b = c = 3;                  equivale a     a = 3; b = 3; c = 3;
Ejemplo de asignaciones:
a += 3;                           equivale a     a = a + 3;
a *= 3;                           equivale a     a = a * 3;
En general:
variable op= expresión   equivale a:   variable = variable op expresión
En la siguiente tabla vemos más ejemplos de asignaciones:
int i = 5, j = 7, x = 2, y = 2, z = 2;
float f = 5.5F, g = -3.25F;
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

Operador condicional.
Lo forman los caracteres  ?  y : 
Se utiliza de la forma siguiente:
expresión1 ? expresión2 : expresión3
Si expresión1 es cierta entonces se evalúa expresión2 y éste será el valor de la expresión condicional. Si expresión1 falsa, se evalúa expresión3 y éste será el valor de la expresión condicional.
Por ejemplo:
int i = 10, j;
j = (i < 0) ? 0 : 100;
Esta expresión asigna a j el valor 100. Su significado es: si el valor de i es menor que 0 asigna a j el valor 0, sino asigna a j el valor 100. Como i vale 10, a j se le asigna 100.
La instrucción anterior es equivalente a escribir:
if(i < 0)
   j = 0;
else
   j = 100;

Más Ejemplos de operador condicional en C++:  
int a=1, b=2, c=3;
c+=(a>0 && a<= 10) ? ++a : a/b;  /* c toma el valor 5*/
int a=50, b=10, c=20;
c+=(a>0 && a<=10) ? ++a : a/b;  /* c toma el valor 25*/
Otros operadores
Operador coma
La coma, usada como operador, se utiliza para encadenar varias expresiones.
Ejemplo:       x=(v=3,v+5)
Equivale a:    v=3
                   x=v+5
Ejemplo:       z=26
           v=(z=z+10,72/z)
Equivale a:    z=26
           z=z+10
           v=72/z
Operador de dirección
Se representa por el símbolo & (ampersand), y su función es la de obtener la dirección dónde se almacena una determinada variable.
Por ejemplo, dadas las siguientes instrucciones:
int x = 10;
cout << “Valor de x: “ << x << endl;
cout << “Dirección de la variable x: “ << &x << endl;
muestran por pantalla:
Valor de x: 10
Dirección de la variable x: 0x27ff44
Operador de indirección
Se representa por un asterisco *,  y su función es la de obtener el valor contenido en una dirección de memoria.
Un puntero es una variable que contiene una dirección de memoria. Para definir una variable puntero se escribe: tipo *variable.
Por ejemplo: int *p;
En el siguiente ejemplo se declara un puntero y dos variables enteras y se utiliza el operador de indirección para obtener el valor contenido en una dirección de memoria.
int *p, x = 10, y = 0;  //se declara el puntero p y las variable x e y
p = &x;                 //a p se le asigna la dirección de memoria de x
y = *p;           //a y se le asigna el valor guardado en la dirección de memoria
que contiene p. Como p contiene la dirección de x, a y se le asigna el valor 10
Veremos los punteros en un tema posterior.
Operador referencia a
Una referencia es un nombre alternativo (un alias, un sinónimo) para un objeto.
La forma general de expresar una referencia es:
tipo &referencia = variable;
Por ejemplo:
float m = 30.01;
float &n = m; // n es una referencia de m
Se ha declarado la variable m como float y n como referencia de m, indicando al compilador que en este programa m también tiene otro nombre ( n ).
Las operaciones realizadas sobre m se reflejan en n, y viceversa. Por lo tanto en el programa podemos utilizar indistintamente m o n.
Una referencia no es una copia de la variable referenciada, sino que es la misma variable con un nombre diferente.
Los operadores no operan con la referencia sino directamente sobre la variable referenciada.
Por ejemplo:
int j = 0;
int &k = j; // k es una referencia a j;
k++;
cout << j << endl;   // muestra 1
cout << k << endl;   // muestra 1;
Una referencia debe ser inicializada y su valor no puede ser alterado después de haberla inicializado, por lo que siempre se referirá al mismo objeto.
Las referencias se utilizan, por ejemplo, como alternativa a los punteros en el paso de parámetros en las funciones.
Operador global y de resolución de ámbito
Es el operador :: y permite el acceso a una variable global que ha quedado oculta por una variable local.
En POO se usa para indicar a qué clase pertenece un determinado método.
Operador sizeof
Obtiene el tamaño en bytes de un tipo de datos o de una variable previamente declarada.
Por Ejemplo, las siguientes instrucciones:
double a;
cout << “Entero-> “ << sizeof(int) << endl;
cout << “Caracter-> “ << sizeof(char) << endl;
cout << “Double-> “ << sizeof(a) << endl;

Dan como resultado:
Entero-> 4
Caracter-> 1;
Double-> 8
El operador sizeof se puede utilizar con tipos primitivos y con tipos derivados.

Prioridad y orden de evaluación de los operadores en C++
La siguiente tabla muestra todos los operadores de C++ ordenados de mayor a menor prioridad.
Los operadores que aparecen en la misma línea tienen la misma prioridad.

::
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:

DdF

C

Descripción

=

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.

DdF

C

Descripción

+

+

Suma, adición

-

-

Resta, sutracción

.

*

Multiplicación, producto

Div

/

Cociente división entera

Mod

%

Resto división entera

/

/

División

Operadores relacionales

DdF

C

Descripción

>

>

Mayor

>=

Mayor o igual

<

<

Menor

<=

Menor o igual

=

==

Igual

!=

Diferente

Operadores lógicos

Los operandos son considerados falsos (valor 0) ó ciertos (valor distinto de 0). El resultado siempre es 0 ó 1.

DdF

C

Descripción

^

&&

And, y, conjunción

||

Or, o, disyunción

¬

!

Not, no, negación

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.

DdF

C

Descripción

AndBB

&

And bit a bit

OrBB

|

Or bit a bit

CompBB

~

Complemento a uno o negación bit a bit

XorBB

^

O-exclusiva bit a bit

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)

DdF

C

Descripción

: ?

: ?

Operador condicional c ? e1 : e2

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.

instrucciones condicionales

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.

1

2

3

4

5

6

7

8

9

10

11

12

13

#include "stdio.h"

 

int main(){

   int edad;

   printf("Escriba su edad: ");

   scanf("%d", &edad);

   if (edad >= 18){

      printf("Ya puedes votar");

   }

   else{

      printf("Todavia eres un niño");

   }

}

 

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.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

#include "stdio.h"

int main(){

   float saldo, deposito, retiro;

   saldo = 300;

   printf("Cuanto deposita: ");

   scanf("%f", &deposito);

   saldo = saldo + deposito;

   printf("Cuanto retira: ");

   scanf("%f", &retiro);

   if (retiro <= saldo){

      saldo = saldo - retiro;

      printf ("Su nuevo saldo es: %.2f", round(saldo));

   }

   else{

      printf("No hay suficiente saldo");

   }

}

 

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.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

#include "stdio.h"

int main(){

   int n;

   printf("Escriba un numero");

   scanf("%d", &n);

   if (n==0){

      printf("Es nulo");

   }

   else{

      if (n<0){

      printf("Es negativo");

      }

      else{

      printf("Es positivo");

      }

   }

}

 

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

#include "stdio.h"

int main(){

   float compra, descuento, total;

   printf("Monto de la compra: ");

   scanf("%f",&compra);

   if (compra < 500){

      descuento = 0;

   }

   if (compra >= 500 && compra < 1000){

      descuento= compra * .10;

   }

   if (compra >= 1000 && compra < 2000){

      descuento = compra * .20;

   }

   if (compra >= 2000){

      descuento = compra * .30;

   }

   total = compra - descuento;

   printf("Su descuento es: %.2f", descuento);

   printf("\nEl total a pagar es: %.2f", total);  

}

 

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.

1

2

3

4

5

6

7

8

9

10

11

12

13

#include "stdio.h"

#include "string.h"

main(){

   char clave[10];

   printf("Escriba su clave: ");

   scanf("%9s", clave); // Solo admitira 9 caracteres

   if (strcmp(clave, "itsa")==0){

      printf("La clave es correcta");

   }

   else{

      printf("La clave 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:

  1. Arithmetic Operators: These are the operators used to perform arithmetic/mathematical operations on operands. Examples: (+, -, *, /, %,++,–). Arithmetic operator are of two types:

    1. Unary Operators: Operators that operates or works with a single operand are unary operators. For example: (++ , –)

    2. Binary Operators: Operators that operates or works with two operands are binary operators. For example: (+ , – , * , /)

  2. To learn Arithmetic Operators in details visit this link.

  3. 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.


  4. 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.

  5. 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.

  6. 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)


  1. 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)


  1. 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)


  1. 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)


  1. If initially value stored in a is 6. Then (a /= 2) = 3.

  1. 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:

    1. 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.

    2. 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.

    3. 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.

Operator

Description

Associativity

()

Parentheses (function call)

left-to-right

[]

Brackets (array subscript)


.

Member selection via object name


->

Member selection via pointer


++/–

Postfix increment/decrement


++/–

Prefix increment/decrement

right-to-left

+/-

Unary plus/minus


!~

Logical negation/bitwise complement


(type)

Cast (convert value to temporary value of type)


*

Dereference


&

Address (of operand)


sizeof

Determine size in bytes on this implementation


*,/,%

Multiplication/division/modulus

left-to-right

+/-

Addition/subtraction

left-to-right

<< , >>

Bitwise shift left, Bitwise shift right

left-to-right

< , <=

Relational less than/less than or equal to

left-to-right

> , >=

Relational greater than/greater than or equal to

left-to-right

== , !=

Relational is equal to/is not equal to

left-to-right

&

Bitwise AND

left-to-right

^

Bitwise exclusive OR

left-to-right

|

Bitwise inclusive OR

left-to-right

&&

Logical AND

left-to-right

||

Logical OR

left-to-right

?:

Ternary conditional

right-to-left

=

Assignment

right-to-left

+= , -=

Addition/subtraction assignment


*= , /=

Multiplication/division assignment


%= , &=

Modulus/bitwise AND assignment


^= , |=

Bitwise exclusive/inclusive OR assignment


<>=

Bitwise shift left/right assignment


,

expression separator

left-to-right




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++

// C program to demonstrate

// working of binary arithmetic

// operators

#include <stdio.h>

 

int main()

{

    int a = 10, b = 4, res;

 

    // printing a and b

    printf("a is %d and b is %d\n", a, b);

 

    res = a + b; // addition

    printf("a+b is %d\n", res);

 

    res = a - b; // subtraction

    printf("a-b is %d\n", res);

 

    res = a * b; // multiplication

    printf("a*b is %d\n", res);

 

    res = a / b; // division

    printf("a/b is %d\n", res);

 

    res = a % b; // modulus

    printf("a%%b is %d\n", res);

 

    return 0;

}

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++

// C program to demonstrate working

// of Unary arithmetic

// operators

#include <stdio.h>

 

int main()

{

    int a = 10, b = 4, res;

 

    // post-increment example:

    // res is assigned 10 only, a is not updated yet

    res = a++;

    printf("a is %d and res is %d\n", a,

           res); // a becomes 11 now

 

    // post-decrement example:

    // res is assigned 11 only, a is not updated yet

    res = a--;

    printf("a is %d and res is %d\n", a,

           res); // a becomes 10 now

 

    // pre-increment example:

    // res is assigned 11 now since

    // a is updated here itself

    res = ++a;

     

    // a and res have same values = 11

    printf("a is %d and res is %d\n", a, res);

 

    // pre-decrement example:

    // res is assigned 10 only since a is updated here

    // itself

    res = --a;

     

    // a and res have same values = 10

    printf("a is %d and res is %d\n", a, res);

 

    return 0;

}

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:

Quiz on Operators in C

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

 




























No hay comentarios:

Publicar un comentario