Introducción
En este laboratorio, aprenderás a respetar el orden de las operaciones en programación C al realizar operaciones aritméticas básicas. Empezarás declarando variables y formando una expresión, luego explorarás cómo usar paréntesis para controlar el orden de evaluación. Finalmente, imprimirás el resultado final para observar el impacto del orden de las operaciones. Este laboratorio cubre los conceptos fundamentales de las operaciones aritméticas básicas en C, esenciales para construir programas más complejos.
Declarar Variables y Formar una Expresión
En este paso, aprenderás a declarar variables y crear una expresión aritmética en C que demuestre el orden de las operaciones.
Primero, crea un nuevo archivo C en el directorio ~/project:
cd ~/project
nano order_of_operations.c
Ahora, introduce el siguiente código:
#include <stdio.h>
int main() {
int a = 10;
int b = 5;
int c = 3;
int result = a + b * c;
printf("Resultado de a + b * c: %d\n", result);
return 0;
}
Analicemos el código:
- Declaramos tres variables enteras:
a,byc. - Creamos una expresión
a + b * cque demostrará el orden de operaciones predeterminado en C. - La instrucción
printfmostrará el resultado de este cálculo.
Compila y ejecuta el programa:
gcc order_of_operations.c -o order_of_operations
./order_of_operations
Salida de ejemplo:
Resultado de a + b * c: 25
En este ejemplo, la multiplicación (b * c) se realiza antes de la suma (a + ...) debido al orden estándar de operaciones en C. El cálculo es equivalente a a + (b * c), que es 10 + (5 * 3) = 10 + 15 = 25.
Usar Paréntesis para Controlar el Orden de Evaluación
En este paso, aprenderás a usar paréntesis para modificar el orden de las operaciones en expresiones aritméticas de C.
Abre el archivo anterior para modificar el código:
cd ~/project
nano order_of_operations.c
Reemplaza el código anterior con el siguiente:
#include <stdio.h>
int main() {
int a = 10;
int b = 5;
int c = 3;
// Usando paréntesis para cambiar el orden de evaluación
int result_with_parentheses = a + (b * c);
int result_without_parentheses = a + b * c;
printf("Resultado con paréntesis (a + (b * c)): %d\n", result_with_parentheses);
printf("Resultado sin paréntesis (a + b * c): %d\n", result_without_parentheses);
return 0;
}
Compila y ejecuta el programa:
gcc order_of_operations.c -o order_of_operations
./order_of_operations
Salida de ejemplo:
Resultado con paréntesis (a + (b * c)): 25
Resultado sin paréntesis (a + b * c): 25
En este ejemplo:
a + (b * c)muestra explícitamente que la multiplicación se realiza primero.- El resultado es el mismo que en el ejemplo anterior porque el orden de operaciones predeterminado ya realiza la multiplicación antes de la suma.
- Los paréntesis ayudan a clarificar el orden de operaciones deseado y pueden modificar los cálculos en expresiones más complejas.
Imprimir el Resultado Final
En este paso, ampliarás el ejemplo anterior creando una expresión aritmética más compleja e imprimiendo resultados detallados para demostrar el orden de las operaciones.
Abre el archivo para modificar el código:
cd ~/project
nano order_of_operations.c
Reemplaza el código anterior con el siguiente:
#include <stdio.h>
int main() {
int a = 10;
int b = 5;
int c = 3;
int d = 2;
// Expresión compleja con múltiples operaciones
int result_default = a + b * c - d;
int result_with_parentheses = a + (b * c - d);
printf("Desglose de la Expresión Original:\n");
printf("a = %d, b = %d, c = %d, d = %d\n", a, b, c, d);
printf("\nEvaluación Predeterminada (a + b * c - d):\n");
printf("Paso 1: b * c = %d\n", b * c);
printf("Paso 2: a + (b * c) = %d\n", a + (b * c));
printf("Paso 3: (a + b * c) - d = %d\n", result_default);
printf("\nEvaluación con Paréntesis (a + (b * c - d)):\n");
printf("Paso 1: b * c - d = %d\n", b * c - d);
printf("Paso 2: a + (b * c - d) = %d\n", result_with_parentheses);
return 0;
}
Compila y ejecuta el programa:
gcc order_of_operations.c -o order_of_operations
./order_of_operations
Salida de ejemplo:
Desglose de la Expresión Original:
a = 10, b = 5, c = 3, d = 2
Evaluación Predeterminada (a + b * c - d):
Paso 1: b * c = 15
Paso 2: a + (b * c) = 25
Paso 3: (a + b * c) - d = 23
Evaluación con Paréntesis (a + (b * c - d)):
Paso 1: b * c - d = 13
Paso 2: a + (b * c - d) = 23
Puntos clave:
- El código demuestra cómo los paréntesis pueden cambiar el orden de las operaciones.
- Mostramos la evaluación paso a paso de las expresiones.
- Ambas expresiones finalmente resultan en el mismo valor (23).
Resumen
En este laboratorio, aprendiste a respetar el orden de las operaciones en la programación C. Primero, declaraste variables y formaste una expresión aritmética para demostrar el orden de operaciones predeterminado, donde la multiplicación se realiza antes de la suma. Luego, utilizaste paréntesis para controlar el orden de evaluación y cambiar el resultado de la expresión. Al comprender la importancia del orden de las operaciones y usar los paréntesis de manera efectiva, puedes escribir programas C más precisos y predecibles.
