OPERADORES Y EXPRESIONES

OPERADORES

Un operador es un símbolo que indica al compilador la ejecución de operaciones matemáticas y lógicas.

Operadores aritméticos

Se ilustran en la tabla siguiente:


Operador	Función
-	Substracción o menos unario
+	Adición
*	Multiplicación
/	División
%	Resto de una división
--	Decremento
++	Incremento

El operador de resto de una división (módulo) da como resultado el resto de una división de dos números enteros. No puede ser por tanto utilizado con el tipo float o double.

#include <stdio.h>
main()
printf("\n 5/2=%f",5/2); /* visualiza 2.5 */
printf("\n resto de 5/2=%d",5%2); /* visualiza 1 */

Incremento y decremento

La operación ++ incrementa en una unidad el operando, La operación -- la decrementa
La expresión x++ es equivalente a x=x+1.
La expresión x-- es equivalente a x=x-1.
Los operadores de incremento y decremento pueden preceder o seguir al operando.La interpretación sin embargo es distinta si le preceden o si le siguen.

main()
{
int x=4;
x++; /* valor de x = 5 */
++x; /* valor de x = 6 */
x--; /* valor de x = 5 */
--x; /* valor de x = 4 */
return x; /* La función main() da en este caso un valor de retorno */
}

En el ejemplo anterior hay una diferencia en la forma de incrementar según esté el operador antes o después. Si se pone antes primero se incrementa/decrementa y después se hace la operación. En el caso de seguir al operando primero se hace la operación y después se incrementa/decrementa. En el ejemplo que sigue se ilustra la diferencia.

x=10;
y=++x; /* y=11 x=11 */
y=x++ /* y=11 x=12 */

Jerarquía relativa a la prioridad de los operadores aritméticos


Operador	Asociatividad
- (unario) ++ --	derecha-izquierda
* / %	izquierda-derecha
== !=	izquierda-derecha
+ -	izquierda-derecha

Operadores relacionales y lógicos

Cuando se habla de operadores relacionales y lógicos el termino relación se refiere a las características que puede haber entre un valor y otro mientras el termino lógico se refiere al modo de unir estas características.
En C el concepto de verdadero o falso se expresa en términos de distinto de cero para verdadero e igual a cero para falso.
Las expresiones que utilizan los operadores relacionales y lógicos dan o bien el valor cero (falso) o distinto de cero (verdadero).
A continuación se da una tabla con dichos operadores:

: Operadores relacionales
Operador	Función
>	Mayor que
>=	Mayor o igual que
<	Menor que
<=	Menor o igual que
==	Igual
!=	No igual (distinto)

: Operadores lógicos
Operador	Función
&&	AND (y)
\|\|	OR (o)
!	NOT( no)

: tabla de verdad de OR AND e NOT
operando1	operando2	AND	OR	oper.	NOT
0	0	0	0	0	1
0	1	0	1	1	0
1	0	0	1
1	1	1	1

#include <stdio.h>
main()
{
int i=5,j=3,k;

k= (j>i); /* k=0 */
k=(i==j); /* k=0 */
k= (j<k); /* k=1 */
k=(j<=k); /* k=1 */

k=(j==i)&&(j!=i); /* k=0 */
k=(j==i)||(j!=i); /* k=1 */
k=!((j==i)&&(j!=i));/* k=1 */

return k;
}

Jerarquía de prioridad en los operadores relacionales y lógicos.

Los operadores aritméticos están un grado más bajos en la jerarquía que los relacionales y lógicos. Esto significa que la expresión 10>1+12 se computa como 10>(1+12).
La jerarquía relativa entre estos es:


Operador	Asociatividad
!	derecha-izquierda
< <= < <=	izquierda-derecha
== !=	izquierda-derecha
&&	izquierda-derecha
\|\|	izquierda-derecha

Operadores de asignación

En C el operador de asignación corresponde al signo igual. A diferencia de otros muchos lenguajes de programación el C permite usar el operador de asignación en expresiones que incluyen operadores relacionales y lógicos

#include <stdio.h>
void main()
{
int x,y,p;
p=x*y;
if (p<0)printf(" p es negativo);
}

La secuencia anterior se podría escribir:
void main()
{
int x,y,p;
if( (p=x*y)<0) printf("p es negativo);
}

EXPRESIONES

En C una expresión es cualquier combinación válida de operadores, constantes y variables. Si en una expresión hay constantes y /o variables de distinto tipo el compilador convierte todos los operandos al tipo al que pertenece el operando de mayor tipo. El ejemplo que sigue ilustra la conversión.

OPERADOR CAST

La conversión se puede forzar a que sea de un tipo determinado por medio del operador cast

(tipo) expresión

main()
{
int x,y
(float)x/i; /* Se fuerza a que sea de tipo float en lugar de int */
}

:expresiones aritméticas

int a=2,b=-3,c=7,d=-19;


Expresión	Equivalencia	Valor
a/b	a/b	0
c/b/c	(c/b)/a	-1
c%a	c%a	1
a%b	a%b	/* depende ...*/
d/b%a	(d/b)%a	0
-a*d	(-a)*d	38
a%-b*c	(a%(-b))*c	14
9/c + -20/d	(9/c)+((-20)/d)	2
-d%c-b/a*5+5	(((-d)%c)-((b/a)*5))+5	15
7-a%(3+b)	7-(a%(3+b))	/* error */
- - -a	-(-(-a))	-2
a=b=c=d=-33	a=(b=(c=(d=(-33))))	-33