Impresión Básica y Salida Estándar

El primer paso en el desarrollo con C es configurar el entorno y generar una salida básica a la consola.

#include <stdio.h>

int main(void) {
    printf("Saludo inicial: Hola Mundo\n");
    return 0;
}

Declaración de Variables y Formateo de Salida

Se demuestra la declaración de variables de distintos tipos primitivos y su posterior impresión utilizando especificadores de formato.

#include <stdio.h>

int main(void) {
    int numeroEntero = 42;
    float numeroDecimal = 3.1415f;
    char letra = 'Z';
    
    printf("Entero: %d\n", numeroEntero);
    printf("Decimal: %f\n", numeroDecimal);
    printf("Caracter: %c\n", letra);
    printf("Fin de la ejecucion.\n");
    
    return 0;
}

Inspección del Tamaño de los Tipos de Datos

Uso del operador sizeof para determinar la cantidad de bytes que ocupa cada tipo de dato en la arquitectura actual.

#include <stdio.h>

int main(void) {
    printf("Tipo de Dato      Tamano (bytes)\n");
    printf("----------------  --------------\n");
    printf("char              %zu\n", sizeof(char));
    printf("int               %zu\n", sizeof(int));
    printf("short             %zu\n", sizeof(short));
    printf("long              %zu\n", sizeof(long));
    printf("float             %zu\n", sizeof(float));
    printf("double            %zu\n", sizeof(double));
    
    return 0;
}

Cálculo de Conversión de Temperatura

Implementación de una fórmula matemática para convertir grados Fahrenheit a Celsius.

#include <stdio.h>

int main(void) {
    double gradosF = 98.6;
    double gradosC = 5.0 * (gradosF - 32.0) / 9.0;
    
    printf("%.2f grados Fahrenheit equivalen a %.2f grados Celsius.\n", gradosF, gradosC);
    
    return 0;
}

Cálculo de Perímetro Geométrico

Ejercicio de aritmética básica para calcular el perímetro de un triángulo dadas las longitudes de sus lados.

#include <stdio.h>

int main(void) {
    int ladoA = 7, ladoB = 8, ladoC = 9;
    int perimetro = ladoA + ladoB + ladoC;
    
    printf("El perimetro del triangulo es: %d\n", perimetro);
    
    return 0;
}

Análisis de Desbordamiento de Enteros (Overflow)

Al utilizar un tipo short (generalmente de 16 bits con signo), el valor máximo representable es 32767.

short valorCorto = 32767;
valorCorto += 1;
printf("%d\n", valorCorto); // Imprime -32768

Explicación técnica: En representación de complemento a dos, sumar 1 al valor máximo (0111...1111) provoca un desbordamiento que envuelve el valor al mínimo negativo (1000...0000), resultando en -32768.

Jerarquía de Operadores Aritméticos

Evaluación de expresiones matemáticas respetendo la precedencia de operadores (multiplicación, división y módulo antes que suma y resta).

• -30 * 3 + 21 / 6 = -90 + 3 = -87
• -30 + 3 * 21 / 6 = -30 + 63 / 6 = -30 + 10 = -20
• 30 / 3 * 21 % 6 = 10 * 21 % 6 = 210 % 6 = 0
• -30 / 3 * 21 % 4 = -10 * 21 % 4 = -210 % 4 = -2

Precedencia de Operadores Relacionales

Dada la expresión i != j < k con variables enteras, es crucial entender que el operador relacional < tiene mayor precedancia que el operador de desigualdad !=.

Corrección conceptual: Primero se evalúa j < k, lo que produce un resultado booleano (0 o 1). Posteriormente, se compara i con ese resultado utilizando !=. Por ejemplo, si j < k es verdadero (1), la expresión final evalúa si i != 1.

Asignación y Truncamiento Implícito

Comportamiento al asignar valores de punto flotante a variables enteras y viceversa.

int i;
double d;
// Caso A
d = i = 3.5; 
// Caso B
i = d = 3.5;

Resultados:

• Caso A: i se convierte a entero (truncando a 3), luego d toma el valor de i (3.0). Resultado: i = 3, d = 3.0.
• Caso B: d toma el valor 3.5, luego i se asigna desde d truncando la parte decimal. Resultado: i = 3, d = 3.5.

Promociones y Conversiones Aritméticas Usuales

Dadas las variables char cval, int ival, unsigned int ui, float fval, y double dval, se analizan las conversiones implícitas en las siguientes expresiones:

1. cval = 'a' + 3; -> Ocurre promoción entera. El char se promociona a int para la suma, y el resultado se trunca al asignarlo de vuelta a char.
2. fval = ui - ival * 1.0; -> ival se convierte a double por el literal 1.0. Luego ui se convierte a double. El resultado double se convierte a float en la asignación.
3. dval = ui * fval; -> ui (unsigned int) se convierte a float para realizar la multiplicación. El resultado float se promociona a double en la asignación.
4. cval = ival + fval + dval; -> ival se convierte a float, luego a double (por dval). El resultado double se trunca y convierte a char al asignarse.

En todos los casos analizados ocurren conversiones de tipo implícitas durante la evaluación y asignación.