C - de Cero a Profesional

Operadores y Expresiones

Operadores aritméticos, relacionales y lógicos

Los operadores aritméticos, relacionales y lógicos son fundamentales en C para realizar diversas operaciones matemáticas, comparaciones y evaluaciones lógicas.

Operadores Aritméticos

  • Suma (+): Suma dos operandos.
  • Resta (-): Resta el segundo operando del primero.
  • Multiplicación (*): Multiplica dos operandos.
  • División (/): Divide el primer operando por el segundo.
  • Módulo (%): Devuelve el residuo de la división del primer operando por el segundo.

Operadores Relacionales

  • Igual (==): Comprueba si dos operandos son iguales.
  • Distinto (!=): Comprueba si dos operandos son diferentes.
  • Mayor (>): Comprueba si el primer operando es mayor que el segundo.
  • Menor (<): Comprueba si el primer operando es menor que el segundo.
  • Mayor o igual (>=): Comprueba si el primer operando es mayor o igual que el segundo.
  • Menor o igual (<=): Comprueba si el primer operando es menor o igual que el segundo.

Operadores Lógicos

  • AND lógico (&&): Devuelve verdadero si ambos operandos son verdaderos.
  • OR lógico (||): Devuelve verdadero si al menos uno de los operandos es verdadero.
  • NOT lógico (!): Devuelve verdadero si el operando es falso y viceversa.

Ejemplo

				
					#include <stdio.h>

int main() {
    // Operadores aritméticos
    int resultadoSuma = 5 + 3;
    int resultadoResta = 8 - 2;
    int resultadoMultiplicacion = 4 * 6;
    int resultadoDivision = 15 / 3;
    int resultadoModulo = 17 % 4;

    // Operadores relacionales
    int num1 = 10, num2 = 20;
    printf("num1 == num2: %d\n", num1 == num2);
    printf("num1 != num2: %d\n", num1 != num2);
    printf("num1 > num2: %d\n", num1 > num2);
    printf("num1 < num2: %d\n", num1 < num2);
    printf("num1 >= num2: %d\n", num1 >= num2);
    printf("num1 <= num2: %d\n", num1 <= num2);

    // Operadores lógicos
    int x = 5, y = 7;
    printf("(x > 3) && (y < 10): %d\n", (x > 3) && (y < 10));
    printf("(x > 3) || (y > 10): %d\n", (x > 3) || (y > 10));
    printf("!(x == y): %d\n", !(x == y));

    return 0;
}

Explicación del Código

  • Operadores aritméticos: Realizan operaciones matemáticas básicas.
  • Operadores relacionales: Comparan dos valores y devuelven 1 (verdadero) o 0 (falso) según el resultado.
  • Operadores lógicos: Realizan operaciones lógicas entre expresiones booleanas y devuelven verdadero o falso.

Operadores de asignación y de incremento/decremento

Los operadores de asignación se utilizan para asignar valores a variables, mientras que los operadores de incremento y decremento se utilizan para aumentar o disminuir el valor de una variable en una unidad.

Operadores de Asignación

  • Asignación (=): Asigna el valor de la expresión a la variable.
  • Asignación con suma (+=): Incrementa el valor de la variable con el valor de la expresión.
  • Asignación con resta (-=): Decrementa el valor de la variable con el valor de la expresión.
  • Asignación con multiplicación (*=): Multiplica el valor de la variable con el valor de la expresión.
  • Asignación con división (/=): Divide el valor de la variable con el valor de la expresión.
  • Asignación con módulo (%=): Asigna el resto de la división del valor de la variable con el valor de la expresión.

Operadores de Incremento y Decremento

  • Incremento (++var o var++): Aumenta el valor de la variable en 1.
  • Decremento (–var o var–): Disminuye el valor de la variable en 1.

Ejemplo

				
					#include <stdio.h>

int main() {
    int a = 5;
    int b = 3;

    // Operadores de asignación
    a += 2; // Equivalente a: a = a + 2;
    b *= 4; // Equivalente a: b = b * 4;

    printf("Después de la asignación: a = %d, b = %d\n", a, b);

    // Operadores de incremento y decremento
    int c = 10;
    int d = 7;

    printf("Valor de c antes del incremento: %d\n", c);
    c++; // Incremento
    printf("Valor de c después del incremento: %d\n", c);

    printf("Valor de d antes del decremento: %d\n", d);
    --d; // Decremento
    printf("Valor de d después del decremento: %d\n", d);

    return 0;
}

Explicación del Código

  • Los operadores de asignación permiten modificar el valor de una variable de manera más concisa.
  • Los operadores de incremento (++var) y decremento (–var) aumentan o disminuyen el valor de la variable en 1 respectivamente.
  • Se pueden usar tanto en la forma prefija (++var) como en la forma sufija (var++). La diferencia radica en cuándo se realiza la operación de incremento o decremento con respecto a la evaluación de la expresión.
  • La forma prefija (++var) incrementa o decrementa la variable antes de que se evalúe la expresión completa.
  • La forma sufija (var++) incrementa o decrementa la variable después de que se evalúe la expresión completa.

Precedencia y asociatividad de operadores

La precedencia y la asociatividad de los operadores en C determinan el orden en que se evalúan las expresiones y cómo se agrupan los operandos en las expresiones compuestas.

Precedencia de Operadores

La precedencia establece el orden en que se evalúan los operadores. Los operadores con mayor precedencia se evalúan primero.

  1. Parentesis (): Mayor precedencia. Las expresiones dentro de paréntesis se evalúan primero.
  2. Operadores de Incremento/Decremento (++ y –): Se evalúan antes que otros operadores.
  3. Operadores Aritméticos (*, /, %): Se evalúan después de los de incremento/decremento.
  4. Operadores Aritméticos (+, -): Tienen menor precedencia que los de multiplicación, división y módulo.
  5. Operadores Relacionales (==, !=, >, <, >=, <=): Se evalúan después de los operadores aritméticos.
  6. Operadores Lógicos (&&, ||): Se evalúan después de los operadores relacionales.
  7. Operadores de Asignación (=, +=, -=, *=, /=, %=): Tienen la menor precedencia.

Asociatividad de Operadores

La asociatividad determina el orden en que se agrupan los operandos cuando hay operadores del mismo nivel de precedencia.

  • Asociatividad Izquierda: Los operadores con la misma precedencia se agrupan de izquierda a derecha.
  • Asociatividad Derecha: Los operadores con la misma precedencia se agrupan de derecha a izquierda.

Ejemplo

				
					#include <stdio.h>

int main() {
    int resultado = 10 * 2 + 5; // Primero se multiplica, luego se suma.
    printf("Resultado: %d\n", resultado);

    int a = 5, b = 3, c = 2;
    int expresion = a + b * c; // Se multiplica b * c primero, luego se suma a.
    printf("Expresion: %d\n", expresion);

    int x = 10, y = 5, z = 3;
    int expresionLogica = x > y && y > z; // && tiene mayor precedencia que >
    printf("Expresion lógica: %d\n", expresionLogica);

    return 0;
}

Explicación del Código

  • En la primera expresión, 10 * 2 se evalúa primero debido a su mayor precedencia, luego se suma 5.
  • En la segunda expresión, b * c se evalúa primero debido a su mayor precedencia, luego se suma a.
  • En la tercera expresión, x > y se evalúa primero debido a su mayor precedencia, luego se evalúa y > z, y finalmente se evalúa && entre ellos.

Recursos