Tipos de datos en C: teoría, práctica y usos

¿Qué tal mis estimados STEAMdiantes?

En la ingeniería, la precisión y la eficiencia son ley. Cuando programamos en C, tenemos que ser explícitos con la computadora. No basta con decir “guarda un número”; debemos especificar: “¿qué clase de número? ¿tiene decimales? ¿es negativo? ¿es una letra?”.

C maneja los datos basándose en cuánto espacio (bytes) ocupan en la memoria RAM y cómo se interpretan esos bits (ceros y unos).

Vamos a categorizarlos en cuatro familias principales: enteros, flotantes, caracteres y el vacío.

Enteros (int)

Sirven para contar cosas que no se pueden dividir (personas, piezas, vueltas de un motor). No tienen punto decimal.

• int (Integer): es el estándar. En la mayoría de las computadoras modernas (arquitectura de 32 o 64 bits), ocupa 4 bytes (32 bits).
  • Rango: desde -2,147,483,648 hasta 2,147,483,647.
  • Uso: contadores, bucles, matemáticas básicas.
  • Identificador printf: %d

Modificadores de tamaño y signo

Podemos alterar el int para ajustarlo a nuestras necesidades:

• short: “entero corto”. Usa menos memoria (generalmente 2 bytes). Rango: -32,768 a 32,767. Ideal para sensores pequeños.
• long: garantiza al menos 32 bits (4 bytes), pero en algunos sistemas (como Linux 64-bit) ocupa 8 bytes.
• long long: “entero muy largo”. Usa más memoria (8 bytes). Para cifras astronómicas.
• signed: la computadora “sacrifica” el primer bit (el de la izquierda) para usarlo como bandera. Si es 0 es positivo, si es 1 es negativo.
  • Consecuencia: te quedan solo 7 bits para guardar el valor numérico. Por eso un signed char llega solo hasta 127.
• unsigned (sin signo):¡vital para ingenieros! si sabes que un dato nunca será negativo (ej. la edad, inventario, RPM), usas unsigned. Esto duplica el rango positivo.
  • Ejemplo: unsigned int va de 0 a 4,294,967,295.

Flotantes (reales)

Sirven para medir el mundo real: temperatura, distancia, presión, dinero. Tienen parte entera y parte decimal.

• float (flotante de precisión simple): ocupa 4 bytes. Tiene una precisión de unos 6-7 dígitos decimales.
  • Uso: gráficos 3D, datos de sensores rápidos donde no importa perder una milésima.
  • Identificador printf: %f
• double (flotante de doble precisión): ocupa 8 bytes. Tiene una precisión de unos 15 dígitos decimales.
  • Uso: cálculos de ingeniería civil, simulaciones físicas, GPS. Es el estándar para matemáticas científicas.
  • Identificador printf: %lf (long float).

Caracteres (char)

Aquí hay un secreto: para C, las letras son números. El tipo char ocupa solo 1 byte (8 bits) y guarda un número entero del -128 al 127.

¿Cómo se convierte en letra? usando la tabla ASCII. Si guardas el número 65, la computadora sabe que representa la letra ‘A’.

• Uso: guardar una letra, un símbolo, o números muy pequeños (como la temperatura de una habitación).
• Identificador printf: %c (para ver la letra) o %d (para ver su código numérico).

El estándar moderno (<stdint.h>)

Como ingenieros profesionales, a veces el int nos da problemas. ¿por qué? porque en una computadora vieja un int puede ser de 16 bits y en una nueva de 32 bits. Si diseñas un puente, esa ambigüedad es inaceptable.

Para eso, incluimos la librería #include <stdint.h> y usamos tipos de ancho fijo:

• int8_t: entero exacto de 8 bits.
• uint16_t: entero sin signo exacto de 16 bits.
• int32_t: entero exacto de 32 bits.
• uint64_t: entero sin signo exacto de 64 bits.

Consejo: si programas microcontroladores o sistemas críticos, usa estos tipos el 90% del tiempo.

El tipo de dato vacío (void)

Este es un concepto filosófico interesante en C. void no representa un valor, sino la ausencia de tipo o la ausencia de valor.

Imagina una caja que está sellada al vacío o que simplemente no existe. No puedes guardar nada dentro de una variable tipo void (no puedes escribir void x = 10;, te daría error).

¿Para qué sirve entonces? es vital para definir protocolos de comunicación entre funciones:

Como retorno de función: indica que la función realiza una acción pero no devuelve ningún resultado matemático.

void encender_led() {
    // Prende la luz, pero no me devuelve ningún numero.
}

Como argumento: indica explícitamente que una función no recibe parámetros.

int main(void) { ... } // "Entro sin nada en las manos"

Punteros genéricos (void*): (nivel avanzado) es un “comodín”. Un puntero void* puede apuntar a cualquier cosa (un int, un char, un float). Es como una etiqueta en blanco que llenaremos después.

¿Y los booleanos? (verdadero/falso)

En el C clásico (C89), no existía true o false. Se usaba 0 para falso y cualquier otra cosa para verdadero. A partir de C99, podemos incluir #include <stdbool.h> y usar el tipo bool que vale true (1) o false (0).

Práctica de tipos de datos en C

Vamos a Visual Studio. Escribe este código para ver cuánto ocupa cada tipo en tu computadora y cómo se comportan.

Usaremos el operador especial sizeof(), que nos dice el tamaño en bytes de un dato.

#include <stdio.h>
#include <stdbool.h> // Para usar bool

int main() {
    // --- Declaración ---
    int entero = 100;
    float decimal_simple = 3.1416f; // La 'f' al final indica que es float
    double decimal_preciso = 3.1415926535;
    char letra = 'Z';
    bool ingeniero_feliz = true;
    unsigned int positivo_grande = 4000000000;

    // --- Salida y Tamaños ---
    printf("=== REPORTE DE TIPOS DE DATOS ===\n\n");

    printf("1. Entero (int): %d \n", entero);
    printf("   Espacio en memoria: %zu bytes\n", sizeof(entero));

    printf("2. Flotante (float): %f \n", decimal_simple);
    printf("   Espacio en memoria: %zu bytes\n", sizeof(decimal_simple));

    printf("3. Doble (double): %.10lf \n", decimal_preciso); // %.10lf muestra 10 decimales
    printf("   Espacio en memoria: %zu bytes\n", sizeof(decimal_preciso));

    printf("4. Caracter (char): %c (Codigo ASCII: %d)\n", letra, letra);
    printf("   Espacio en memoria: %zu bytes\n", sizeof(letra));

    printf("5. Booleano: %d (1 es true, 0 es false)\n", ingeniero_feliz);

    printf("6. Unsigned Int: %u \n", positivo_grande); // %u es para unsigned

    return 0;
}

Verás que double imprime muchos más decimales correctos que float.
Verás que char puede imprimirse como letra (Z) o como número (90), demostrando que en el fondo es un entero.
Verás con tus propios ojos cuántos bytes consume cada variable en tu sistema.

Impresionante, ¿no? En los próximos artículos haremos matemáticas con estos datos para reforzar nuestros conocimientos.

Gracias por leernos.
Si te gusto este artículo, únete a nuestra comunidad en Facebook o WhatsApp para más…
¡Hasta la próxima!