Operadores en Rust: Aritmética, Comparación y Lógica

Los operadores son símbolos que le indican al compilador que realice operaciones matemáticas, lógicas o de comparación sobre valores. En Rust, es fundamental entender cómo se comportan los tipos de datos con estos operadores, ya que la precisión y la lógica dependen de ellos.

Los operadores aritméticos se utilizan para cálculos matemáticos básicos: suma (+), resta (-), multiplicación (*), división (/) y residuo (%). Un detalle crucial en Rust es que la división entre dos enteros trunca el resultado hacia cero (por ejemplo, 7 / 2 es 3, no 3.5). Para calcular potencias, Rust no utiliza un operador especial (como ^ en otros lenguajes, donde ^ es XOR), sino que emplea métodos como .pow() para enteros o .powf() para números de punto flotante.

Los operadores de comparación (==, !=, <, >, <=, >=) comparan dos valores y devuelven un tipo booleano (true o false). Para que dos tipos puedan compararse, deben implementar los rasgos PartialEq (igualdad) y PartialOrd (orden).

Los operadores lógicos permiten combinar condiciones. El operador && (AND) y || (OR) utilizan un mecanismo llamado “cortocircuito”: en un &&, si la primera condición es falsa, la segunda ni siquiera se evalúa porque el resultado ya es false. En un ||, si la primera es verdadera, se ignora la segunda. El operador ! (NOT) invierte el valor booleano.

Finalmente, Rust destaca por no tener un operador ternario clásico (como condicion ? a : b); en su lugar, se utiliza la expresión if para devolver un valor. Además, no existen los operadores de incremento o decremento ++ o --; para esto, se debe usar la asignación compuesta o una operación aritmética directa.

fn main() {
    // --- Operadores Aritméticos ---
    let a: i32 = 10;
    let b: i32 = 3;
    let suma = a + b;          // Suma: 13
    let division = a / b;       // División entera: 3 (trunca el decimal)
    let modulo = a % b;         // Residuo de la división: 1
    let potencia = a.pow(2);     // Potencia (10^2): 100

    // --- Operadores de Comparación ---
    let es_igual = a == b;      // Compara si son iguales: false
    let es_mayor = a > b;       // Compara si a es mayor que b: true

    // --- Operadores Lógicos ---
    // El operador && es "cortocircuito"
    let logico_and = es_igual && es_mayor; // false && true -> false
    // El operador || es "cortocircuito"
    let logico_or = es_igual || es_mayor;  // false || true -> true
    let logico_not = !es_igual;            // NOT false -> true

    // --- If como Expresión (Sustituye al operador ternario) ---
    let mensaje = if a > b { "Mayor" } else { "Menor" };

    // --- Asignación Compuesta y Mutabilidad ---
    let mut c = 10;
    c += 5; // Equivalente a c = c + 5

    // --- Operadores de Bits ---
    let bit_and = a & b; // Operación AND a nivel de bits

    println!(
        "Aritmética: {}, {}, {}, {}. Comparación: {}, {}. Lógica: {}, {}, {}. If: {}. Asignación: {}. Bit: {}",
        suma, division, modulo, potencia, es_igual, es_mayor, logico_and, logico_or, logico_not, mensaje, c, bit_and
    );
}

Explicación del Código

– a y b son variables de tipo i32 (enteros de 32 bits) que sirven como base para las operaciones.
– suma almacena el resultado de a + b (13).
– division muestra la trunca de a / b, resultando en 3.
– modulo obtiene el residuo de 10 / 3, que es 1.
– potencia utiliza el método .pow(2) sobre a para calcular $10^2$.
– es_igual resulta false al comparar si 10 == 3.
– es_mayor resulta true ya que 10 > 3.
– logico_and es false porque la primera condición (es_igual) es falsa, aplicando cortocircuito.
– logico_or es true porque la segunda condición (es_mayor) es verdadera.
– logico_not invierte es_igual (false) convirtiéndolo en true.
– mensaje es una variable que recibe un valor mediante la expresión if, funcionando como un operador ternario para asignar "Mayor".
– c es declarada con mut para permitir la asignación compuesta +=.
– bit_and realiza una operación AND bit a bit entre a (1010) y b (0011), resultando en 2 (0010).

N° 19