Tipos de datos en C: int, float, char, double y más

Cada variable en C tiene un tipo, elegido cuando la declaras y fijo durante toda su vida. El tipo decide tres cosas: cuántos bytes ocupa la variable, cómo se interpretan esos bytes y qué operaciones tienen sentido sobre ella.

La lista de tipos de C es corta. La complejidad está en los modificadores.

Los cuatro tipos base

#include <stdio.h>

int main(void) {
    char  initial = 'K';        /* un carácter / un byte */
    int   count   = 42;         /* número entero */
    float ratio   = 3.14f;      /* decimal, precisión simple */
    double precise = 3.141592653589793;  /* decimal, precisión doble */

    printf("char:   %c\n", initial);
    printf("int:    %d\n", count);
    printf("float:  %f\n", ratio);
    printf("double: %.15f\n", precise);
    return 0;
}

• char guarda un byte. Se usa para caracteres individuales ('A'), para los bytes de una cadena y a veces como un entero diminuto.
• int es el tipo de número entero de uso general. Contadores de bucles, tamaños, identificadores.
• float y double guardan números reales. double tiene aproximadamente el doble de precisión.
• void es el cuarto tipo en cierto sentido, pero significa "sin valor": no puedes declarar una variable void, solo usarlo como tipo de retorno de una función, como lista de parámetros vacía o como puntero sin tipo.

Fíjate en el sufijo f de 3.14f. Sin él el literal es un double, y asignarlo a un float pierde precisión en silencio. Algunos compiladores lo advierten.

Modificadores: short, long, unsigned

Los tipos enteros base vienen con modificadores que cambian el tamaño o el signo.

#include <stdio.h>

int main(void) {
    short small = 32000;
    int normal = 2000000;
    long big = 2000000000L;
    long long huge = 9000000000000000000LL;

    unsigned int positive_only = 4000000000U;

    printf("short:        %hd\n", small);
    printf("int:          %d\n", normal);
    printf("long:         %ld\n", big);
    printf("long long:    %lld\n", huge);
    printf("unsigned int: %u\n", positive_only);
    return 0;
}

Cada tipo entero necesita su propio especificador de formato: %hd para short, %d para int, %ld para long, %lld para long long, %u para unsigned. Usar el equivocado es comportamiento indefinido, no un error de redondeo.

unsigned elimina el bit de signo y duplica el rango positivo. Un unsigned int guarda de 0 a unos 4.300 millones en lugar de -2.100 a +2.100 millones. Es la elección correcta para cosas que genuinamente no pueden ser negativas — tamaños, conteos de bytes, patrones de bits — y una trampa para cualquier cosa a la que se le pueda restar por debajo de cero.

signed es el valor por defecto para int, short, long y long long, así que casi nunca lo escribes. El único lugar donde importa es char: si un char simple es con signo o sin signo queda definido por la implementación, así que escribe signed char o unsigned char cuando el signo importe.

Tamaños: lo que realmente obtienes

El estándar de C especifica mínimos, no tamaños exactos. En cualquier máquina moderna de 64 bits con Linux, macOS o Windows verás esto:

La fila de long es la que agarra desprevenida a la gente: son 8 bytes en Linux y macOS, y 4 bytes en Windows de 64 bits. El código que asume que long puede guardar un valor de 64 bits no es portable. Usa long long, o los tipos de ancho exacto de stdint.h (int32_t, uint64_t) cuando el tamaño sea parte del requisito.

sizeof: pregúntale al compilador

Nunca adivines un tamaño: mídelo.

#include <stdio.h>

int main(void) {
    printf("char:        %zu byte(s)\n", sizeof(char));
    printf("short:       %zu bytes\n", sizeof(short));
    printf("int:         %zu bytes\n", sizeof(int));
    printf("long:        %zu bytes\n", sizeof(long));
    printf("long long:   %zu bytes\n", sizeof(long long));
    printf("float:       %zu bytes\n", sizeof(float));
    printf("double:      %zu bytes\n", sizeof(double));
    printf("un puntero:  %zu bytes\n", sizeof(int *));
    return 0;
}

sizeof es un operador, no una función, y se evalúa en tiempo de compilación. Produce un valor de tipo size_t, que se imprime con %zu.

sizeof(char) está garantizado que es exactamente 1: esa es la definición de byte en C. Todo lo demás se mide en relación con eso.

limits.h y float.h

Los rangos exactos de tu compilador están disponibles como constantes con nombre:

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    printf("INT_MIN      = %d\n", INT_MIN);
    printf("INT_MAX      = %d\n", INT_MAX);
    printf("UINT_MAX     = %u\n", UINT_MAX);
    printf("LONG_MAX     = %ld\n", LONG_MAX);
    printf("CHAR_BIT     = %d bits por byte\n", CHAR_BIT);
    printf("FLT_DIG      = %d digitos decimales\n", FLT_DIG);
    printf("DBL_DIG      = %d digitos decimales\n", DBL_DIG);
    return 0;
}

Estos son los valores con los que comparar cuando necesitas saber si una operación se va a desbordar. Comprobar if (a > INT_MAX - b) antes de calcular a + b es la forma de detectar el desbordamiento antes de que ocurra, lo cual importa, porque no puedes detectar el desbordamiento con signo después.

Desbordamiento de enteros

Qué pasa cuando un valor excede el rango de su tipo depende por completo del signo.

El desbordamiento sin signo está definido: el valor da la vuelta módulo 2^N.

#include <stdio.h>
#include <limits.h>

int main(void) {
    unsigned int u = UINT_MAX;
    printf("UINT_MAX     = %u\n", u);
    printf("UINT_MAX + 1 = %u\n", u + 1);   /* garantizado que es 0 */

    unsigned int zero = 0;
    printf("0 - 1        = %u\n", zero - 1); /* da la vuelta a UINT_MAX */
    return 0;
}

Ese segundo caso es una fuente real de errores. Un bucle como for (unsigned i = n - 1; i >= 0; i--) nunca termina, porque un valor sin signo siempre es >= 0.

El desbordamiento con signo es comportamiento indefinido. No "da la vuelta": indefinido. Al compilador se le permite asumir que nunca ocurre y optimizar sobre esa base, lo que significa que una comprobación de desbordamiento escrita después del hecho puede ser eliminada:

int sum = a + b;
if (sum < a) { /* el compilador puede eliminar esto por completo */ }

Compruébalo antes, usando los límites:

if (b > 0 && a > INT_MAX - b) {
    /* a + b se desbordaría: manéjalo */
}

Precisión de punto flotante

float y double guardan los números en binario, y la mayoría de las fracciones decimales no tienen forma binaria exacta, de la misma manera que 1/3 no tiene forma decimal exacta.

#include <stdio.h>

int main(void) {
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;

    printf("0.1 + 0.2 = %.20f\n", sum);
    printf("Es 0.3? %s\n", (sum == 0.3) ? "si" : "no");

    /* La forma correcta: comparar dentro de una tolerancia. */
    double diff = sum - 0.3;
    if (diff < 0) diff = -diff;
    printf("Suficientemente cerca? %s\n", (diff < 1e-9) ? "si" : "no");
    return 0;
}

La regla que se deduce: nunca compares valores de punto flotante con ==. Compara en cambio la diferencia absoluta contra una tolerancia pequeña.

Y nunca uses punto flotante para dinero. Guarda los centavos como un entero; un long long de centavos es exacto donde un double de pesos no lo es.

Elegir un tipo

Una lista corta de decisiones que cubre la mayor parte del código:

• Números enteros: int a menos que tengas una razón. Es el tipo que la CPU maneja con más eficiencia y el tipo alrededor del cual están construidas todas las reglas aritméticas.
• Cualquier cosa mayor a 2.000 millones: long long, o int64_t de stdint.h.
• Tamaños, longitudes e índices de arrays provenientes de sizeof o strlen: size_t. Es sin signo y está garantizado que es lo bastante grande para cualquier objeto.
• Decimales: double. Usa float solo para reducir a la mitad la memoria en arrays grandes o en hardware embebido sin unidad de doble precisión.
• Caracteres individuales y bytes crudos: char para texto, unsigned char para datos binarios.
• Verdadero/falso: bool de stdbool.h — mira booleanos en C.
• Anchos de bits exactos (formatos de archivo, protocolos de red, registros de hardware): stdint.h — uint8_t, int16_t, uint32_t, y así sucesivamente.

#include <stdio.h>
#include <stdint.h>

int main(void) {
    uint8_t  flags = 0xFF;          /* exactamente 8 bits, sin signo */
    int32_t  offset = -100000;      /* exactamente 32 bits, con signo */
    uint64_t file_size = 5000000000ULL;

    printf("flags:     %u\n", flags);
    printf("offset:    %d\n", offset);
    printf("file_size: %llu bytes\n", (unsigned long long)file_size);
    return 0;
}

Mezclar tipos

Cuando combinas dos tipos distintos en una misma expresión, C los convierte a tus espaldas antes de hacer la aritmética. Eso suele ser útil y ocasionalmente desastroso:

#include <stdio.h>

int main(void) {
    int a = 7, b = 2;

    printf("7 / 2  como ints = %d\n", a / b);        /* 3, no 3.5 */
    printf("7 / 2  con 2.0   = %f\n", a / 2.0);      /* 3.5 */

    int  small = -1;
    unsigned int big = 1;
    printf("-1 < 1u ? %s\n", (small < big) ? "si" : "no");  /* sorprendente */
    return 0;
}

La primera es división entera: ambos operandos son int, así que el resultado es un int y la fracción se descarta. La tercera es peor: comparar un valor con signo con uno sin signo convierte el que tiene signo a sin signo, convirtiendo -1 en un número positivo enorme.

Esas reglas de conversión, y cómo tomar el control de ellas con conversiones explícitas, son el tema de conversión de tipos en C.