Please enable JavaScript.

Coggle requires JavaScript to display documents.

Operadores en Programación Estructurada operadores, Antonio Ricardo…

Operadores en Programación Estructurada

Operadores de Incremento y Decremento

Operador de Incremento

En lenguajes tipo C, el operador es escrito como ++ :
ejemplo:

         int  x;                                                            
         int  y;    

           // Operadores de incremento                                                       
           x = 1;                                                      
           y = ++x;    // x es ahora 2, y es también 2                                                       
           y = x++;    // x es ahora 3, y es 2

Operador de Decremento

En lenguajes tipo C, el operador de decremento como -- :

           int  x;                                                            
           int  y;  

            // Operadores de decremento                                                       
            x = 3;                                                       
            y = x--;    // x es ahora 1, y es 2                                                        
            y = --x;    // x es ahora 2, y es también 2

- - - - Ejemplo:
        Sintaxis
        ~cast-expresion
        signed int s1 = ~2; // equivale a: signed int s1 = compl 2; signed int s2 = ~s1 + 2;
        En la primera línea, el complemento a uno de 2 es asignado al entero con signo s1. Tenga en cuenta que el resultado de este operador cambia el signo del operando, de ahí el "signed".
  - - - Ejemplo:
        Sintaxis
        AND-expresion & equality-expresion
        int x = 10, y = 20; int z = x & y; // equivale a: int z = x bitand y;
        En este caso el resultado del AND lógico entre los enteros 10 y 20 se aplicaría al entero z.
  - - - Ejemplo:
        Sintaxis
        expr-OR-exclusiva ^ AND-expresion
        int x = 10, y = 20; int z = x ^ y; // equivale a: int z = x xor y;
  - - - Ejemplo:
        Sintaxis
        expr-desplazada >> expr-desplazamiento
        unsigned long x = 10; unsigned long z = x >> 2;
        El resultado es del tipo del primer operando.
  - - - Ejemplo:
        Sintaxis
        expr-OR-inclusiva | expr-OR-exclusiva
        int x = 10, y = 20; int z = x | y; // equivale a: int z = x bitor y;
  - - - Ejemplo:
        Sintaxis
        expr-desplazada << expr-desplazamiento
        unsigned long x = 10; int y = 2; unsigned long z = x << y;
        El resultado del desplazamiento de 2 bits sobre el unsigned long x es asignado al unsigned long y sin que sea necesario ningún "casting" para el tipo resultante.

Operadores Aritméticos

Multiplicación

El operador * multiplica los valores de tipo de datos numéricos.

       const int X = 10;
       const int y = 2;                                
       int multiplicacion;                                                           
       multiplicacion = X * Y;                                                       
       printf (Resultado multiplicacion 10 + 2:  %d", multiplicacion);                                                      
       Resultado multiplicacion 10 x 2: 20

División

Obtiene la división según el tipo de dato entre los operandos.
Entero / entero: genera un entero
Real / real; Entero / real; real /entero: genera un real

           const int X = 10;
           const int y = 2;                                
           int division;                                                           
           division = X / Y;                                                       
           printf (Resultado division 10 / 2:  %d", division);                                                      
           Resultado division 10 / 2: 5

Resta

El operador - resta los valores de tipo de datos numéricos.
Ejemplo:

           const int X = 10;
           const int y = 2;                                
           int resta;                                                           
           resta = X - Y;                                                       
           printf (Resultado resta 10 - 2:  %d", resta);                                                      
           Resultado resta 10 - 2: 8

Potenciación

Obtiene la potencia de la base elevada al exponente. La radicación puede obtenerse del inverso de la potencia.

           const int X = 10;
           const int y = 2;                                
           int potencia;                                                           
           potencia = pow(X,Y);                                                       
           printf (Resultado potencia 10 a la 2:  %d", potencia);                                                      
           Resultado potencia 10 a la 2: 100

Suma

El operador + suma los valores de tipo de datos numéricos.
Ejemplo:

           const int X = 10;
           const int y = 2;                                
           int suma;                                                           
           suma = X + Y;                                                       
           printf (Resultado suma 10 + 2:  %d", suma);                                                      
           Resultado suma 10 + 2: 12

Operadores de asignación y expresiones

Operador =

El operador igual a, (=), es el más simple de todos y asigna a la variable del lado izquierdo cualquier variable o resultado del lado derecho.

Ejemplo:

       / / operador =;
       int a;                                
       a=10;                                                           
       printf ("El valor de a es: %i", a);                                                      
       El valor de a es: 10

Operador +=

El operador += suma a la variable del lado izquierdo el valor del lado derecho.

Ejemplo:

       / / operador +=;
       int a;                                
       a = 10;  
       a += 10;                             
       printf ("El valor de a es: %i", a);                                                      
       El valor de a es: 20

Operador -=

El operador -= resta a la variable del lado izquierdo el valor del lado derecho.

Ejemplo:

       / / operador -=;
       int a;                                
       a = 10;  
       a -= 5;                             
       printf ("El valor de a es: %i", a);                                                      
       El valor de a es: 5

Operador *=

El operador *= multiplica a la variable del lado izquierdo el valor del lado derecho.

Ejemplo:

       / / operador *=;
       int a;                                
       a = 10;  
       a *= 2;                             
       printf ("El valor de a es: %i", a);                                                      
       El valor de a es: 20

Operador /=

El operador /= divide a la variable del lado izquierdo el valor del lado derecho.

Ejemplo:

       / / operador /=;
       int a;                                
       a = 10;  
       a /= 2;                             
       printf ("El valor de a es: %i", a);                                                      
       El valor de a es: 5