Implementar operadores de C++

Introducción

En este laboratorio, aprenderás cómo implementar varios operadores de C++, incluyendo operaciones matemáticas básicas, incremento/decremento, operadores relacionales y lógicos, operaciones a nivel de bits, asignación compuesta, orden de operaciones y el operador condicional ternario. Estos operadores fundamentales son esenciales para realizar cálculos aritméticos, hacer comparaciones y manipular datos en la programación de C++. A través de una serie de ejercicios prácticos, adquirirás una comprensión sólida de cómo utilizar eficazmente estos operadores para construir aplicaciones de C++ más complejas y eficientes.

Realizar operaciones matemáticas básicas (+, -, *, /, %)

En este paso, aprenderás cómo realizar operaciones matemáticas básicas en C++. Las operaciones matemáticas son fundamentales para la programación y te permiten manipular valores numéricos utilizando operadores aritméticos estándar.

Abre el WebIDE y crea un nuevo archivo llamado math_operations.cpp en el directorio ~/project:

touch ~/project/math_operations.cpp

Agrega el siguiente código al archivo math_operations.cpp:

#include <iostream>

int main() {
    // Declare variables for mathematical operations
    int a = 10;
    int b = 3;

    // Addition (+)
    int sum = a + b;
    std::cout << "Addition: " << a << " + " << b << " = " << sum << std::endl;

    // Subtraction (-)
    int difference = a - b;
    std::cout << "Subtraction: " << a << " - " << b << " = " << difference << std::endl;

    // Multiplication (*)
    int product = a * b;
    std::cout << "Multiplication: " << a << " * " << b << " = " << product << std::endl;

    // Division (/)
    int quotient = a / b;
    std::cout << "Division: " << a << " / " << b << " = " << quotient << std::endl;

    // Modulus (%) - Remainder of division
    int remainder = a % b;
    std::cout << "Modulus: " << a << " % " << b << " = " << remainder << std::endl;

    return 0;
}

Compila y ejecuta el programa:

g++ math_operations.cpp -o math_operations
./math_operations

Ejemplo de salida:

Addition: 10 + 3 = 13
Subtraction: 10 - 3 = 7
Multiplication: 10 * 3 = 30
Division: 10 / 3 = 3
Modulus: 10 % 3 = 1

Desglosemos los operadores matemáticos:

+ (Suma): Suma dos números. Por ejemplo, 5 + 3 daría como resultado 8.
- (Resta): Resta el segundo número del primero. Por ejemplo, 10 - 4 daría como resultado 6.
* (Multiplicación): Multiplica dos números. Por ejemplo, 6 * 7 daría como resultado 42.
/ (División): Divide el primer número por el segundo. Cuando ambos números son enteros, esto resulta en una división entera, lo que significa que la parte decimal se trunca. Por ejemplo, 10 / 3 daría como resultado 3.
% (Módulo): Devuelve el resto de la división. Por ejemplo, 10 % 3 daría como resultado 1 porque el resto de dividir 10 entre 3 es 1.

Algunas notas importantes:

La división entera trunca la parte decimal. Por ejemplo, 5 / 2 dará como resultado 2, no 2.5.
El operador de módulo solo funciona con tipos enteros. No se puede utilizar con números de punto flotante (como float o double).
Siempre ten cuidado con la división por cero, que causa errores en tiempo de ejecución. Tu programa se bloqueará si intentas dividir cualquier número por cero.

Usar incremento/decremento pre y post (++i, i++)

En este paso, aprenderás sobre los operadores de incremento y decremento en C++. Estos operadores te permiten aumentar o disminuir el valor de una variable en 1, con sutiles diferencias entre el incremento previo y el incremento posterior.

Abre el WebIDE y crea un nuevo archivo llamado increment_decrement.cpp en el directorio ~/project:

touch ~/project/increment_decrement.cpp

Agrega el siguiente código al archivo increment_decrement.cpp:

#include <iostream>

int main() {
    // Pre-increment (++i)
    int a = 5;
    std::cout << "Original value of a: " << a << std::endl;

    // Pre-increment: increment happens before the value is used
    std::cout << "Pre-increment (++a): " << ++a << std::endl;
    std::cout << "Value after pre-increment: " << a << std::endl;

    // Post-increment (i++)
    int b = 5;
    std::cout << "\nOriginal value of b: " << b << std::endl;

    // Post-increment: increment happens after the value is used
    std::cout << "Post-increment (b++): " << b++ << std::endl;
    std::cout << "Value after post-increment: " << b << std::endl;

    // Decrement operators work similarly
    int c = 5;
    std::cout << "\nPre-decrement (--c): " << --c << std::endl;

    int d = 5;
    std::cout << "Post-decrement (d--): " << d-- << std::endl;
    std::cout << "Value after post-decrement: " << d << std::endl;

    return 0;
}

Compila y ejecuta el programa:

g++ increment_decrement.cpp -o increment_decrement
./increment_decrement

Ejemplo de salida:

Original value of a: 5
Pre-increment (++a): 6
Value after pre-increment: 6

Original value of b: 5
Post-increment (b++): 5
Value after post-increment: 6

Pre-decrement (--c): 4
Post-decrement (d--): 5
Value after post-decrement: 4

Diferencias clave:

Incremento previo ++i: Incrementa el valor antes de que se use en la expresión. En el ejemplo de código, ++a primero incrementa a a 6, y luego el valor 6 se usa en la instrucción cout.
Incremento posterior i++: Utiliza el valor actual en la expresión primero, y luego incrementa el valor. En el ejemplo de código, b++ primero utiliza el valor actual de b, que es 5, en la instrucción cout, y luego incrementa b a 6.

Los mismos principios se aplican a los operadores de decremento --i y i--, donde --i decrementa primero y luego utiliza el valor, y i-- utiliza el valor primero y luego decrementa.

Notas importantes:

El incremento previo cambia el valor antes de que se use en una expresión, lo que significa que el valor incrementado está inmediatamente disponible para su uso.
El incremento posterior utiliza el valor original primero y luego incrementa. Esto significa que obtienes el valor original en la declaración actual y el valor incrementado en la siguiente.
Estos operadores se utilizan comúnmente en bucles (como los bucles for) y expresiones complejas donde se desea modificar una variable mientras se utiliza su valor.
Al utilizar estos operadores, especialmente en expresiones complejas, es importante tener en cuenta si se necesita la versión previa o posterior para obtener el comportamiento deseado.

Comparar valores usando operadores relacionales (<, >, ==,!=)

En este paso, aprenderás sobre los operadores relacionales en C++. Estos operadores te ayudan a comparar valores y determinar relaciones entre diferentes números o variables.

Abre el WebIDE y crea un nuevo archivo llamado relational_operators.cpp en el directorio ~/project:

touch ~/project/relational_operators.cpp

Agrega el siguiente código al archivo relational_operators.cpp:

#include <iostream>

int main() {
    int a = 10;
    int b = 5;
    int c = 10;

    // Less than (<)
    std::cout << "Less than (<):" << std::endl;
    std::cout << a << " < " << b << " is " << (a < b) << std::endl;
    std::cout << b << " < " << a << " is " << (b < a) << std::endl;

    // Greater than (>)
    std::cout << "\nGreater than (>):" << std::endl;
    std::cout << a << " > " << b << " is " << (a > b) << std::endl;
    std::cout << b << " > " << a << " is " << (b > a) << std::endl;

    // Equal to (==)
    std::cout << "\nEqual to (==):" << std::endl;
    std::cout << a << " == " << b << " is " << (a == b) << std::endl;
    std::cout << a << " == " << c << " is " << (a == c) << std::endl;

    // Not equal to (!=)
    std::cout << "\nNot equal to (!=):" << std::endl;
    std::cout << a << "!= " << b << " is " << (a!= b) << std::endl;
    std::cout << a << "!= " << c << " is " << (a!= c) << std::endl;

    return 0;
}

Compila y ejecuta el programa:

g++ relational_operators.cpp -o relational_operators
./relational_operators

Ejemplo de salida:

Less than (<):
10 < 5 is 0
5 < 10 is 1

Greater than (>):
10 > 5 is 1
5 > 10 is 0

Equal to (==):
10 == 5 is 0
10 == 10 is 1

Not equal to (!=):
10!= 5 is 1
10!= 10 is 0

Puntos clave sobre los operadores relacionales:

< (Menor que): Comprueba si el valor de la izquierda es menor que el valor de la derecha. Por ejemplo, 5 < 10 es verdadero (devuelve 1), mientras que 10 < 5 es falso (devuelve 0).
> (Mayor que): Comprueba si el valor de la izquierda es mayor que el valor de la derecha. Por ejemplo, 10 > 5 es verdadero (devuelve 1), mientras que 5 > 10 es falso (devuelve 0).
== (Igual a): Comprueba si dos valores son exactamente iguales. Por ejemplo, 5 == 5 es verdadero (devuelve 1), mientras que 5 == 6 es falso (devuelve 0).
!= (Diferente de): Comprueba si dos valores no son iguales. Por ejemplo, 5!= 6 es verdadero (devuelve 1), mientras que 5!= 5 es falso (devuelve 0).
Estos operadores devuelven 1 (verdadero) o 0 (falso). En C++, 1 representa verdadero y 0 representa falso. Estos valores se pueden utilizar en sentencias condicionales.

Notas importantes:

Los operadores relacionales son fundamentales para crear sentencias condicionales, lo que permite que tu programa tome decisiones basadas en comparaciones.
Siempre devuelven un valor booleano, que se representa por un entero en C++ (1 para verdadero, 0 para falso).
Estos operadores se utilizan comúnmente en sentencias if, bucles while y bucles for para controlar el flujo de ejecución.

Combinar condiciones con AND lógico (&&) y OR lógico (||)

En este paso, aprenderás cómo combinar múltiples condiciones utilizando los operadores AND lógico (&&) y OR lógico (||) en C++. Estos operadores te ayudan a crear sentencias condicionales más complejas evaluando múltiples condiciones.

Abre el WebIDE y crea un nuevo archivo llamado logical_operators.cpp en el directorio ~/project:

touch ~/project/logical_operators.cpp

Agrega el siguiente código al archivo logical_operators.cpp:

#include <iostream>

int main() {
    int x = 10;
    int y = 5;
    int z = 15;

    // Logical AND (&&) operator
    std::cout << "Logical AND (&&) operator:" << std::endl;

    // Both conditions must be true
    if (x > y && x < z) {
        std::cout << "x is greater than y AND less than z" << std::endl;
    }

    if (x > 20 && y < 10) {
        std::cout << "This will not be printed" << std::endl;
    }

    // Logical OR (||) operator
    std::cout << "\nLogical OR (||) operator:" << std::endl;

    // At least one condition must be true
    if (x > 20 || y < 10) {
        std::cout << "At least one condition is true" << std::endl;
    }

    if (x > 20 || z < 20) {
        std::cout << "Another true condition" << std::endl;
    }

    // Combining AND and OR
    std::cout << "\nCombining AND and OR:" << std::endl;

    if ((x > y && y < z) || x == 10) {
        std::cout << "Complex condition is true" << std::endl;
    }

    return 0;
}

Compila y ejecuta el programa:

g++ logical_operators.cpp -o logical_operators
./logical_operators

Ejemplo de salida:

Logical AND (&&) operator:
x is greater than y AND less than z

Logical OR (||) operator:
At least one condition is true
Another true condition

Combining AND and OR:
Complex condition is true

Puntos clave sobre los operadores lógicos:

&& (AND): Ambas condiciones conectadas por && deben ser verdaderas para que toda la expresión sea verdadera. Si cualquiera de las condiciones es falsa, toda la expresión se evalúa como falsa. En el código, x > y && x < z es verdadera porque x > y (10 > 5) y x < z (10 < 15) son ambas verdaderas.
|| (OR): Al menos una de las condiciones conectadas por || debe ser verdadera para que toda la expresión sea verdadera. Si todas las condiciones son falsas, toda la expresión se evalúa como falsa. En el código, x > 20 || y < 10 es verdadera porque y < 10 (5 < 10) es verdadera.
Puedes combinar múltiples condiciones utilizando paréntesis para controlar el orden de evaluación. Esto hace que tus expresiones complejas sean más fáciles de leer y entender.
Estos operadores son extremadamente útiles para crear lógica de toma de decisiones compleja dentro de sentencias condicionales.

Notas importantes:

Los operadores lógicos se utilizan a menudo en sentencias if, bucles while y otras estructuras de control de flujo para hacer que tus programas sean más versátiles.
Ayudan a crear comprobaciones condicionales más sofisticadas al permitirte comprobar múltiples criterios simultáneamente.
Evaluación de cortocircuito:
- Para &&, si la primera condición es falsa, la segunda condición no se evalúa porque toda la expresión será falsa independientemente de lo que sea la segunda condición. Esta optimización puede mejorar el rendimiento.
- Para ||, si la primera condición es verdadera, la segunda condición no se evalúa porque toda la expresión será verdadera.

Aplicar operaciones bit a bit para manipulación binaria

En este paso, aprenderás sobre los operadores a nivel de bits en C++. Estos operadores trabajan directamente sobre la representación binaria de enteros, lo que te permite manipular bits individuales.

Abre el WebIDE y crea un nuevo archivo llamado bitwise_operations.cpp en el directorio ~/project:

touch ~/project/bitwise_operations.cpp

Agrega el siguiente código al archivo bitwise_operations.cpp:

#include <iostream>
#include <bitset>

int main() {
    // Binary representation of numbers
    unsigned int a = 5;   // 0101 in binary
    unsigned int b = 3;   // 0011 in binary

    // Bitwise AND (&)
    std::cout << "Bitwise AND (&):" << std::endl;
    std::cout << "a = " << std::bitset<4>(a) << " (5 in decimal)" << std::endl;
    std::cout << "b = " << std::bitset<4>(b) << " (3 in decimal)" << std::endl;
    unsigned int and_result = a & b;
    std::cout << "a & b = " << std::bitset<4>(and_result)
              << " (" << and_result << " in decimal)" << std::endl;

    // Bitwise OR (|)
    std::cout << "\nBitwise OR (|):" << std::endl;
    unsigned int or_result = a | b;
    std::cout << "a | b = " << std::bitset<4>(or_result)
              << " (" << or_result << " in decimal)" << std::endl;

    // Bitwise XOR (^)
    std::cout << "\nBitwise XOR (^):" << std::endl;
    unsigned int xor_result = a ^ b;
    std::cout << "a ^ b = " << std::bitset<4>(xor_result)
              << " (" << xor_result << " in decimal)" << std::endl;

    // Bitwise NOT (~)
    std::cout << "\nBitwise NOT (~):" << std::endl;
    unsigned int not_result = ~a;
    std::cout << "~a = " << std::bitset<32>(not_result)
              << " (" << not_result << " in decimal)" << std::endl;

    // Left shift (<<)
    std::cout << "\nLeft Shift (<<):" << std::endl;
    unsigned int left_shift = a << 2;
    std::cout << "a << 2 = " << std::bitset<8>(left_shift)
              << " (" << left_shift << " in decimal)" << std::endl;

    // Right shift (>>)
    std::cout << "\nRight Shift (>>):" << std::endl;
    unsigned int right_shift = a >> 1;
    std::cout << "a >> 1 = " << std::bitset<4>(right_shift)
              << " (" << right_shift << " in decimal)" << std::endl;

    return 0;
}

Compila y ejecuta el programa:

g++ bitwise_operations.cpp -o bitwise_operations
./bitwise_operations

Ejemplo de salida:

Bitwise AND (&):
a = 0101 (5 in decimal)
b = 0011 (3 in decimal)
a & b = 0001 (1 in decimal)

Bitwise OR (|):
a | b = 0111 (7 in decimal)

Bitwise XOR (^):
a ^ b = 0110 (6 in decimal)

Bitwise NOT (~):
~a = 11111111111111111111111111111010 (4294967290 in decimal)

Left Shift (<<):
a << 2 = 00010100 (20 in decimal)

Right Shift (>>):
a >> 1 = 0010 (2 in decimal)

Puntos clave sobre los operadores a nivel de bits:

& (AND): Compara los bits correspondientes de dos números. Si ambos bits son 1, el bit resultante es 1; de lo contrario, es 0. En el ejemplo de código, 5 & 3 (binario 0101 & 0011) da como resultado 0001, que es 1 en decimal.
| (OR): Compara los bits correspondientes de dos números. Si al menos uno de los bits es 1, el bit resultante es 1; de lo contrario, es 0. En el ejemplo, 5 | 3 (binario 0101 | 0011) da como resultado 0111, que es 7 en decimal.
^ (XOR): Compara los bits correspondientes de dos números. Si los bits son diferentes, el bit resultante es 1; de lo contrario, es 0. En el ejemplo, 5 ^ 3 (binario 0101 ^ 0011) da como resultado 0110, que es 6 en decimal.
~ (NOT): Invierte todos los bits de un número. Si un bit es 1, se convierte en 0, y viceversa. Ten en cuenta que la salida ~a es 11111111111111111111111111111010, que es la representación binaria del resultado cuando el número se trata como un entero sin signo de 32 bits.
<< (Desplazamiento a la izquierda): Desplaza los bits de un número hacia la izquierda un número especificado de posiciones. En efecto, multiplica el número por 2 por cada desplazamiento. En el ejemplo, 5 << 2 (binario 0101 << 2) desplaza los bits para convertirse en 010100, que es 20 en decimal.
>> (Desplazamiento a la derecha): Desplaza los bits de un número hacia la derecha un número especificado de posiciones. En efecto, divide el número por 2 por cada desplazamiento. En el ejemplo, 5 >> 1 (binario 0101 >> 1) desplaza los bits para convertirse en 0010, que es 2 en decimal.

Notas importantes:

Las operaciones a nivel de bits trabajan directamente sobre las representaciones binarias de enteros, lo que permite una manipulación y optimización a bajo nivel.
Se utilizan comúnmente en sistemas incrustados, programación gráfica y situaciones en las que necesitas establecer, borrar o probar bits individuales dentro de un valor.
Ten cuidado con los enteros con signo y sin signo, ya que el comportamiento del desplazamiento a la derecha puede variar (desplazamiento aritmético vs. lógico).
El uso de std::bitset ayuda a visualizar cómo funcionan estas operaciones a nivel de bits.

Usar operadores de asignación compuesta (+=, -=, *=)

En este paso, aprenderás sobre los operadores de asignación compuesta en C++. Estos operadores combinan una operación aritmética con la asignación, lo que hace que tu código sea más conciso y legible.

Abre el WebIDE y crea un nuevo archivo llamado compound_operators.cpp en el directorio ~/project:

touch ~/project/compound_operators.cpp

Agrega el siguiente código al archivo compound_operators.cpp:

#include <iostream>

int main() {
    // Initialize variables
    int x = 10;
    int y = 5;

    // Addition assignment (+=)
    std::cout << "Addition Assignment (+=):" << std::endl;
    std::cout << "Initial x: " << x << std::endl;
    x += 3;  // Equivalent to x = x + 3
    std::cout << "x += 3: " << x << std::endl;

    // Subtraction assignment (-=)
    std::cout << "\nSubtraction Assignment (-=):" << std::endl;
    std::cout << "Initial y: " << y << std::endl;
    y -= 2;  // Equivalent to y = y - 2
    std::cout << "y -= 2: " << y << std::endl;

    // Multiplication assignment (*=)
    std::cout << "\nMultiplication Assignment (*=):" << std::endl;
    int z = 4;
    std::cout << "Initial z: " << z << std::endl;
    z *= 3;  // Equivalent to z = z * 3
    std::cout << "z *= 3: " << z << std::endl;

    // Division assignment (/=)
    std::cout << "\nDivision Assignment (/=):" << std::endl;
    int a = 15;
    std::cout << "Initial a: " << a << std::endl;
    a /= 3;  // Equivalent to a = a / 3
    std::cout << "a /= 3: " << a << std::endl;

    // Modulus assignment (%=)
    std::cout << "\nModulus Assignment (%=):" << std::endl;
    int b = 17;
    std::cout << "Initial b: " << b << std::endl;
    b %= 5;  // Equivalent to b = b % 5
    std::cout << "b %= 5: " << b << std::endl;

    return 0;
}

Compila y ejecuta el programa:

g++ compound_operators.cpp -o compound_operators
./compound_operators

Ejemplo de salida:

Addition Assignment (+=):
Initial x: 10
x += 3: 13

Subtraction Assignment (-=):
Initial y: 5
y -= 2: 3

Multiplication Assignment (*=):
Initial z: 4
z *= 3: 12

Division Assignment (/=):
Initial a: 15
a /= 3: 5

Modulus Assignment (%=):
Initial b: 17
b %= 5: 2

Puntos clave sobre los operadores de asignación compuesta:

+= (Sumar y asignar): Suma el operando derecho al operando izquierdo y asigna el resultado al operando izquierdo. x += 3 es equivalente a x = x + 3.
-= (Restar y asignar): Resta el operando derecho del operando izquierdo y asigna el resultado al operando izquierdo. y -= 2 es equivalente a y = y - 2.
*= (Multiplicar y asignar): Multiplica el operando izquierdo por el operando derecho y asigna el resultado al operando izquierdo. z *= 3 es equivalente a z = z * 3.
/= (Dividir y asignar): Divide el operando izquierdo por el operando derecho y asigna el resultado al operando izquierdo. a /= 3 es equivalente a a = a / 3.
%= (Módulo y asignar): Calcula el módulo del operando izquierdo por el operando derecho y asigna el resultado al operando izquierdo. b %= 5 es equivalente a b = b % 5.

Notas importantes:

Los operadores de asignación compuesta hacen que tu código sea más conciso y fácil de leer al combinar una operación y una asignación en un solo paso.
Funcionan con todas las operaciones aritméticas básicas (+, -, *, /, %).
Pueden ayudar a reducir la cantidad de escritura, hacer el código más corto y, potencialmente, mejorar el rendimiento.

Comprender el orden de operaciones con múltiples operadores

En este paso, aprenderás sobre el orden de operaciones en C++, a menudo recordado por el acrónimo PEMDAS (Paréntesis, Exponentes, Multiplicación y División, Suma y Resta). Comprender este orden es crucial para escribir expresiones matemáticas correctas.

Abre el WebIDE y crea un nuevo archivo llamado order_of_operations.cpp en el directorio ~/project:

touch ~/project/order_of_operations.cpp

Agrega el siguiente código al archivo order_of_operations.cpp:

#include <iostream>

int main() {
    // Basic order of operations demonstration
    int a = 10;
    int b = 5;
    int c = 3;

    // Multiplication before addition
    std::cout << "Multiplication before Addition:" << std::endl;
    int result1 = a + b * c;
    std::cout << "a + b * c = " << result1 << std::endl;

    // Parentheses change the order of operations
    std::cout << "\nParentheses change order:" << std::endl;
    int result2 = (a + b) * c;
    std::cout << "(a + b) * c = " << result2 << std::endl;

    // Complex expression with multiple operators
    std::cout << "\nComplex Expression:" << std::endl;
    int x = 4;
    int y = 2;
    int z = 3;

    int complex_result = x + y * z - (x / y);
    std::cout << "x + y * z - (x / y) = " << complex_result << std::endl;

    // Demonstrating precedence with increment and multiplication
    std::cout << "\nIncrement and Multiplication:" << std::endl;
    int m = 3;
    int n = 2;
    int precedence_result = m++ * n;
    std::cout << "m++ * n = " << precedence_result << std::endl;
    std::cout << "m after operation = " << m << std::endl;

    return 0;
}

Compila y ejecuta el programa:

g++ order_of_operations.cpp -o order_of_operations
./order_of_operations

Ejemplo de salida:

Multiplication before Addition:
a + b * c = 25

Parentheses change order:
(a + b) * c = 45

Complex Expression:
x + y * z - (x / y) = 8

Increment and Multiplication:
m++ * n = 6
m after operation = 4

Puntos clave sobre el orden de operaciones:

El orden de operaciones, también conocido como precedencia de operadores, determina cómo se evalúa una expresión. C++ sigue las reglas de las matemáticas para esto.
PEMDAS/BODMAS: Este es un mnemotécnico común para recordar el orden:
- Paréntesis / Braces: Las expresiones dentro de paréntesis o corchetes se evalúan primero.
- Exponentes / Orders: Los exponentes u órdenes (como raíces cuadradas) se evalúan a continuación, aunque C++ no tiene un operador de exponente incorporado, este paso se refiere a operaciones como pow().
- MD Multiplicación y División: La multiplicación y la división tienen la misma precedencia y se evalúan de izquierda a derecha.
- AS Suma y Resta: La suma y la resta tienen la misma precedencia y se evalúan de izquierda a derecha.
En el código, int result1 = a + b * c; se evalúa como 10 + (5 * 3) que es 10 + 15 = 25 porque la multiplicación tiene una precedencia mayor que la suma.
Los paréntesis pueden anular el orden de operaciones predeterminado, haciendo que la expresión int result2 = (a + b) * c; se evalúe como (10 + 5) * 3 que es 15 * 3 = 45, ya que la expresión dentro de los paréntesis se calcula primero.
Los operadores de incremento/decremento tienen reglas de precedencia específicas que a veces pueden ser confusas. En el operador de post-incremento m++ utilizado en el código, el valor original de m se utiliza primero en la multiplicación m * n y solo después la variable m se incrementa.
En la expresión compleja x + y * z - (x / y), la multiplicación y la división se realizan antes de la suma y la resta. Los paréntesis aseguran que la división entera x / y se realice primero.
Siempre utiliza paréntesis para dejar clara tu intención, especialmente cuando tienes expresiones complicadas. Esto no solo hace que el código sea más fácil de leer, sino que también asegura que la expresión se evalúe exactamente como se pretendió.

Notas importantes:

PEMDAS/BODMAS ayuda a predecir cómo se evaluarán las expresiones, pero ten en cuenta que C++ no tiene un operador de exponente incorporado.
Cuando tengas dudas, utiliza paréntesis para definir explícitamente el orden. Esto puede hacer que tu código sea más claro y prevenir errores que pueden ocurrir debido a una mala comprensión de la precedencia.
Algunos operadores tienen la misma precedencia y se evalúan de izquierda a derecha. Por ejemplo, si tienes a - b + c, la resta se realizará antes de la suma.
Ten especial cuidado cuando combinas múltiples operadores en una sola expresión sin utilizar paréntesis. Puede llevar a errores sutiles si no comprendes adecuadamente la precedencia de los operadores.

Practicar con el operador condicional ternario

En este paso, aprenderás sobre el operador condicional ternario, una forma compacta de escribir sentencias if-else simples en una sola línea. Este operador proporciona un método conciso para tomar decisiones en tu código.

Abre el WebIDE y crea un nuevo archivo llamado ternary_operator.cpp en el directorio ~/project:

touch ~/project/ternary_operator.cpp

Agrega el siguiente código al archivo ternary_operator.cpp:

#include <iostream>

int main() {
    // Basic ternary operator syntax
    // condition? value_if_true : value_if_false

    // Simple comparison
    int x = 10;
    int y = 5;

    // Determine the larger number
    int max_value = (x > y)? x : y;
    std::cout << "Larger value: " << max_value << std::endl;

    // Check if a number is even or odd
    int number = 7;
    std::string result = (number % 2 == 0)? "Even" : "Odd";
    std::cout << number << " is " << result << std::endl;

    // Nested ternary operator
    int a = 15;
    std::string category = (a < 10)? "Small"
                         : (a < 20)? "Medium"
                         : "Large";
    std::cout << "Category: " << category << std::endl;

    // Ternary operator with function calls
    int abs_value = (x < 0)? -x : x;
    std::cout << "Absolute value of x: " << abs_value << std::endl;

    // Ternary operator in output
    std::cout << "Is x greater than y? "
              << ((x > y)? "Yes" : "No") << std::endl;

    return 0;
}

Compila y ejecuta el programa:

g++ ternary_operator.cpp -o ternary_operator
./ternary_operator

Ejemplo de salida:

Larger value: 10
7 is Odd
Category: Medium
Absolute value of x: 10
Is x greater than y? Yes

Puntos clave sobre el operador ternario:

Sintaxis: condition? value_if_true : value_if_false. Es una forma abreviada de escribir una sentencia if-else en una sola línea.
La condition se evalúa. Si es verdadera, la expresión devuelve value_if_true; de lo contrario, devuelve value_if_false.
En el código, int max_value = (x > y)? x : y; determina el número mayor entre x e y. Si x es mayor que y, asignará x a max_value; de lo contrario, asignará y. Dado que x es 10 e y es 5, max_value se convierte en 10.
La expresión std::string result = (number % 2 == 0)? "Even" : "Odd"; utiliza el operador módulo % para verificar si el número es par o impar. El resultado es "Even" o "Odd", dependiendo del resultado de la comprobación, y se asigna a la variable de cadena result.
Los operadores ternarios se pueden anidar, pero hacerlo puede hacer que el código sea difícil de leer rápidamente. En el ejemplo, el operador ternario anidado asigna la cadena "Small", "Medium" o "Large" a la variable category dependiendo del valor del entero a.
El ejemplo con int abs_value = (x < 0)? -x : x; demuestra cómo se puede usar el operador ternario para obtener el valor absoluto de x. Si x es negativo, negará x, lo que es equivalente a convertirlo en su valor absoluto. De lo contrario, devolverá x tal cual.
El último ejemplo muestra cómo se puede imprimir directamente el resultado de un operador ternario: std::cout << "Is x greater than y? " << ((x > y)? "Yes" : "No") << std::endl;

Notas importantes:

Úsalo con moderación para mantener la legibilidad del código. El uso excesivo de operadores ternarios, especialmente los anidados, puede hacer que el código sea difícil de seguir.
Puede volverse difícil de leer si es demasiado complejo. Las decisiones complejas a menudo deben expresarse con bloques if-else completos.
Se utiliza principalmente para condiciones simples y directas en las que se necesita devolver o asignar uno de dos valores.

Resumen

En este laboratorio, aprendiste cómo realizar operaciones matemáticas básicas en C++, incluyendo suma, resta, multiplicación, división y módulo. También exploraste el uso de operadores de incremento/decremento pre y post, comprendiendo las sutiles diferencias entre ellos. Además, aprendiste sobre operadores relacionales y lógicos para comparar y combinar valores de manera efectiva. Además, practicaste operaciones a nivel de bits para manipulación binaria y operadores de asignación compuesta para simplificar y condensar operaciones aritméticas con asignación. Finalmente, adquiriste una comprensión del orden de operaciones con múltiples operadores y utilizaste el operador condicional ternario para sentencias condicionales concisas. Estos conceptos fundamentales son esenciales para construir programas en C++ robustos y eficientes. Al dominar estos operadores básicos, estarás bien preparado para enfrentar desafíos de codificación más complejos.