Tipos de operadores y ejemplos en C

Concepto de operador en C

“Un operador es un elemento de programa que se aplica a uno o varios operandos en una expresión o instrucción. Los operadores que requieren un operando, como el operador de incremento se conocen como operadores unarios. Los operadores que requieren dos operandos, como los operadores aritméticos (+,-,*,/) se conocen como operadores binarios. Un operador, el operador condicional (?:), utiliza tres operandos y es el único operador ternario de C.

Existen 6 tipos de operadores según su función, que son aritméticos, relacionales, de asignación, 

lógicos, de dirección y de manejo de Bits.

Operadores aritméticos

Operación	Acción
x++	Postincremento
++x	Preincremento
x--	Predecremento
+x	+ Unario
-x	- Unario
x*y	Multiplicación
x/y	División
x%y	Módulo
x+y	Suma
x-y	Resta

Los operadores incremento y decremento proporcionan una forma breve de sumar o restar 1 a una variable. Usados como prefijo, como ++i, el valor de la variable se incrementa (decrementa) antes de que la variable sea usada; usada como sufijo, como i++ el valor de la variable se incrementa (decrementa) despues de su utilizacion.

Ejemplo:

Hacer una calculadora básica en C

#include 

int main() {
 
      int x,y; /*Declaración de variables a utilizar*/
 
      printf("\nCalculadorea en C\n\n1.-Suma"); /*Creación del menú*/
      printf("\n2.-Resta");
      printf("\n3.-Multiplicacion");
      printf("\n4.-Division");
      printf("\n\nSeleccion una opcion: ");
      scanf("%d",&x); /*Se guardará la opción en la variable x*/ 
 
      switch(x){ /*Se usará switch para realizar cada operación*/
      case 1: 
              printf("\nIngresa un numero: ");
              scanf("%d",&x); /*para no declarar más variables se
                              sobreescribirá x*/
              printf("\nIngresa otro numero: ");
              scanf("%d",&y);
  
              printf("\nla suma de %d + %d = %d",x,y,x+y); /*Operador suma*/
              break;
      case 2: 
              printf("\nIngresa un numero: ");
              scanf("%d",&x);
              printf("\nIngresa otro numero: ");
              scanf("%d",&y);
              printf("\nla resta de %d - %d = %d",x,y,x-y); /*Operador resta*/
              break;
      case 3: 
              printf("\nIngresa un numero: ");              scanf("%d",&x);
              printf("\nIngresa otro numero: ");
              scanf("%d",&y);
              printf("\nla multiplicacion de %d * %d = %d",x,y,x*y); /*Operador
                                                               multiplicacion*/
              break;
      case 4: 
              printf("\nIngresa un numero: ");
              scanf("%d",&x);
              printf("\nIngresa otro numero: ");
              scanf("%d",&y);
              printf("\nla devisión de %d / %d = %d",x,y,x/y); /*Operador 
                                                                Division*/
              printf(" y el residuo es %d",x%y);/*Operador Módulo*/
              break;
      }
 
      return 0;
}

Operadores relacionales.

Los operadores relacionales comparan sus operandos y devuelven el valor 1 si la relacion es cierta y 0 si no lo es. Son:

Operador	Propósito
<	Menor que
<=	Menor o igual que
>	Mayor que
>=	Mayor o igual que
==	Igual que
!=	Direrente de

Ejemplo:

Hacer un programam en C que pida dos número, los compare y diga si son iguales, diferentes y cual es el mayor.

#include 

int main() {
      int x,y;
 
      printf("\nIngresa un numero ");
      scanf("%d",&x);
      printf("\nIngresa otro numero: ");
      scanf("%d",&y);
 
      if(x==y)
            printf("\n%d y %d son iguales",x,y); 
      else if(x!=y){
            printf("\n%d y %d no son iguales",x,y);
            if(x>y)
                  printf("\n\n%d es mayor que %d",x,y);
            if(x&l;ty)
                  printf("\n\n%d es menor que %d",x,y);
      }
      return 0;
}

Operadores logicos.

Operador	Accion
!	Negación lógica
&&	Y lógico
||	O lógico

Veamos qué significan cada uno de ellos:

valor = (expresion1 && expresion2)

En este caso si expresion1 y expresion2 son verdaderas, el valor resulta verdadero (true).

Si alguna o ambas de las expresiones son falsas, el valor resulta en falso (false).

valor = (expresion1 || expresion2)

En este caso si ambas expresiones son verdaderas, el valor resulta verdadero.

Si una de las expresiones es verdadera y la otra falsa, el valor resulta verdadero.

Si las dos expresiones son falsas, el valor resulta falso.

valor = (!expresion1)

En este caso si la expresión es verdadera, el valor resulta falso.

Si la expresión es falsa, el valor resulta falso.

Ejemplo:

#include 

int main() {
      int x;

      printf("\nIngresa tu edad: ");
      scanf("%d",&x); /*El valor ingresados guardará en x*/
 
      if(x>=12 && x<=18) /*El operador && nos dice que si
        eres mayor o igual a 12 y menor o igual a 18 eres un
        adolescente, si alguna de las 2 condiciones no se 
        cumple, entonces no se jecutará la intrucción*/
            printf("\nEres un adolescente\n");
      else
            printf("\Es usted un adulto");
 
      return 0;
}

#include 

int main() {
      int x;
 
      printf("\nIngresa tu edad: ");
      scanf("%d",&x);
 
      if(!(x>17)) /*Niega por completo la expresión*/
            printf("\nAun no eres un adulto");
      else 
            printf("\nEs usted un adulto");
 
      return 0;
}

Los valores logicos en C estan representados por enteros: 0 es falso y un valor no cero es verdadero. Por ejemplo, el operador ! toma un operando numerico y devuelve int 1 para un operando cero y int 0 En el lenguaje caso contrario. El operador && devuelve 1 si los dos operandos son valores no cero y 0 en el lenguaje cualquier otro caso. El operador || devuelve 1 si cualquiera de los dos operandos es no cero y 0 en otro caso. Los operadores && y || evaluan primero el operando de su izquierda, y no evaluan el operando de la derecha si no es necesario.

Por ejemplo, si y es cero, la expresion y && x/y da 0 y no realiza la division por 0.

Precedencia de operadores.

La interpretación de cualquier expresión en el lenguaje C esta determinada por la precedencia y asociatividad de los operadores en dicha expresión. Cada operador tiene una precedencia y los operadores en una expresión se evalúan en orden de mayor a menor precedencia. La evaluación de operadores con la misma precedencia viene determinada por su asociatividad. Y, al igual que en matemáticas, los paréntesis anulan las reglas de precedencia.

En la siguiente tabla se listan los operadores en el lenguaje C, su precedencia y su asociatividad. Los operadores se listan en orden de prioridad decreciente (los situados mas arriba tienen mayor prioridad). Los operadores en la misma linea horizontal tienen la misma precedencia.

Operador	Propósito	Asociatividad
::	Scope (unario)	De derecha a izquierda
::	Scope (binario)	De izquierda a derecha
-> .	Seleccion de miembros	De izquierda a derecha
[]	indices	De izquierda a derecha
()	Llamada a funcion	De izquierda a derecha
++	Postincremento	De izquierda a derecha
--	Postdecremento	De izquierda a derecha
sizeof	Tamaño de un objeto	De derecha a izquierda
++	Preincremento	De derecha a izquierda
--	Predecremento	De derecha a izquierda
* & + - ! ~	Operadores unarios	De derecha a izquierda
new	Crea un objeto	De derecha a izquierda
delete	Borra un objeto	De derecha a izquierda
()	Conversion de tipo (type cast)	De derecha a izquierda
->* .*	Puntero a un miembro	De izquierda a derecha
* / %	Operadores multiplicativos	De izquierda a derecha
+ -	Operadores aditivos	De izquierda a derecha
<< >>	Operadores bitwise	De izquierda a derecha
< > <= >=	Operadores de relacion	De izquierda a derecha
== !=	Operadores de igualdad	De izquierda a derecha
&	Y bitwise	De izquierda a derecha
^	bitwise O exclusivo	De izquierda a derecha
|	bitwise O inclusivo	De izquierda a derecha
&&	Y logico	De izquierda a derecha
||	O logico	De izquierda a derecha
?:	Operador condicional	De derecha a izquierda
= *= /= += -= >*gt;= &= ^= |= %= <<=	Operadores de asignacion	De derecha a izquierda
,	Operador coma	De derecha a izquierda

En el lenguaje C las reglas de precedencia y asociatividad de operadores corresponden a las reglas matemáticas. Sin embargo, esto no funcionara, por ejemplo, con los operadores bitwise. Para tales operadores, se debe utilizar la tabla anterior, o bien parentesis.