csharp-precedencia-operadores

Precedencia de operadores en C#

La precedencia de operadores define el orden en el que se evalúan los diferentes operadores en una expresión sin paréntesis.

Los operadores con mayor precedencia se evalúan antes que los operadores con menor precedencia. Si dos operadores tienen la misma precedencia, su evaluación se determina por la asociatividad del operador (izquierda a derecha o derecha a izquierda).

Si quieres aprender más sobre Precedencia de operadores


consulta el Curso de Introducción a la Programación leer más ⯈ :::

Tabla de precedencia de operadores

En C#, los operadores se agrupan en niveles de precedencia. A continuación, os pongo a una tabla que muestra algunos de los operadores más comunes organizados por su precedencia, de mayor a menor.

PrecedenciaOperadorDescripciónAsociatividad
1()ParéntesisN/A
2++, --Incremento y decrementoPostfijo
3+, -Unario positivo y negativoDerecha a izquierda
4*, /, %Multiplicación, división, móduloIzquierda a derecha
5+, -Adición, sustracciónIzquierda a derecha
6<<, >>Desplazamiento de bitsIzquierda a derecha
7<, >, <=, >=ComparaciónIzquierda a derecha
8==, !=Igualdad, desigualdadIzquierda a derecha
9&AND bit a bitIzquierda a derecha
10^XOR bit a bitIzquierda a derecha
11``OR bit a bit
12&&AND lógicoIzquierda a derecha
13``
14?:Operador condicional (ternario)Derecha a izquierda
15=, +=, -=Asignación y operadores compuestosDerecha a izquierda

Cómo funciona la precedencia de operadores

Evaluación de expresiones

La precedencia de operadores determina el orden de evaluación en expresiones complejas. Por ejemplo, supongamos que tenemos la siguiente expresión:

int resultado = 3 + 4 * 2; // equivale a 3 + (4 * 2) = 11 

En esta expresión, la multiplicación (*) tiene una mayor precedencia que la adición (+). Por lo tanto, 4 * 2 se evalúa primero, dando 8, y luego se suma 3, resultando en 11.

Uso de paréntesis

Para cambiar el orden de evaluación, podemos emplear a nuestros fieles amigos, los paréntesis. Los paréntesis tienen la mayor precedencia y fuerzan la evaluación de la expresión que contienen primero.

int resultado = (3 + 4) * 2;

Aquí, 3 + 4 se evalúa primero debido a los paréntesis, dando 7, y luego se multiplica por 2, resultando en 14.

Asociatividad

Cuando los operadores tienen la misma precedencia, la asociatividad determina el orden de evaluación. La mayoría de los operadores en C# tienen asociatividad de izquierda a derecha, lo que significa que se evalúan de izquierda a derecha.

Sin embargo, algunos operadores, como los operadores de asignación, tienen asociatividad de derecha a izquierda.

int a = 1;
int b = 2;
int c = 3;
int resultado = a + b - c;

En este ejemplo, tanto + como - tienen la misma precedencia y asociatividad de izquierda a derecha. Por lo tanto, a + b se evalúa primero, dando 3, y luego 3 - c se evalúa, resultando en 0.

Ejemplo complejo

Consideremos una expresión más compleja para ilustrar cómo se combinan precedencia y asociatividad:

int resultado = 5 + 2 * 3 - 4 / 2 + (1 + 3);

Evaluamos paso a paso según la precedencia y asociatividad:

  1. Evaluamos la expresión en paréntesis: (1 + 3), que resulta en 4.
  2. Evaluamos la multiplicación: 2 * 3, que resulta en 6.
  3. Evaluamos la división: 4 / 2, que resulta en 2.
  4. Evaluamos las operaciones restantes de izquierda a derecha:
    • 5 + 6 resulta en 11.
    • 11 - 2 resulta en 9.
    • 9 + 4 resulta en 13.

Por lo tanto, el resultado final de la expresión es 13.

Buenas prácticas Consejos

Aunque la precedencia de operadores permite omitir paréntesis en muchas situaciones, es una buena práctica usar paréntesis para mejorar la claridad del código. Esto no solo hace que el código sea más fácil de entender, sino que también reduce la probabilidad de errores.

int resultado = (5 + 2) * (3 - 1);

Comprensión de operadores compuestos

Los operadores compuestos, como += y -=, combinan la asignación con otra operación. Estos operadores tienen una precedencia más baja, lo que puede afectar el resultado de las expresiones si no se entienden correctamente.

int a = 5;
a += 3 * 2; // a = a + (3 * 2)
Console.WriteLine(a); // Salida: 11

En este ejemplo, 3 * 2 se evalúa primero debido a su mayor precedencia, luego el resultado 6 se suma a a.