Docs ejecutables de C++: Tipos de datos

Q: ¿Cuáles son los tipos de datos básicos en C++?

Los tipos fundamentales son los enteros (short, int, long, long long), los de coma flotante (float, double, long double), el tipo de carácter char y el tipo booleano bool. Cada tipo entero puede ser además signed o unsigned. Todo lo demás - std::string, los arrays, tus propias clases - se construye sobre estos.

Q: ¿Cuál es la diferencia entre int y long en C++?

Ambos almacenan números enteros, pero se garantiza que long sea al menos tan ancho como int (a menudo 64 bits en plataformas de 64 bits, pero solo 32 bits en Windows). El estándar solo fija los tamaños mínimos, así que para un ancho garantizado usa los tipos de ancho fijo de como int32t e int64t.

Q: ¿Cuánto ocupa un int en C++?

El estándar solo garantiza que int tenga al menos 16 bits, pero en prácticamente todos los equipos de escritorio y servidores modernos son 32 bits. Como los tamaños dependen de la plataforma, nunca lo des por sentado - imprime sizeof(int) para comprobarlo, o usa tipos de como int32_t cuando necesites un ancho exacto.

Por qué importan los tipos en C++

En la página de variables declaraste valores con un tipo explícito como int age = 30;. Ese tipo no es solo una etiqueta - le indica al compilador cuántos bytes reservar, cómo interpretar esos bytes y qué operaciones son legales. Equivócate de tipo y puedes perder precisión silenciosamente, desbordar o provocar comportamiento indefinido.

C++ agrupa sus tipos integrados en unas pocas familias: enteros, números de coma flotante, un tipo de carácter y un booleano. Veamos cada uno y, después, las reglas que hacen tropezar a la gente.

Los tipos fundamentales

Aquí tienes uno de cada tipo básico en un solo programa. Fíjate en los sufijos de los literales (L, f, u) y en las comillas simples de char:

#include <iostream>
using namespace std;

int main() {
    int    count = 42;          // número entero, normalmente de 32 bits
    long long big = 9000000000LL; // entero más ancho, el sufijo LL
    double price = 19.99;       // decimal de 64 bits (el predeterminado para decimales)
    float  ratio = 0.5f;        // decimal de 32 bits - fíjate en la f
    char   grade = 'A';         // un solo carácter, comillas simples
    bool   passed = true;       // solo true o false

    cout << count << " " << big << "\n";
    cout << price << " " << ratio << "\n";
    cout << grade << " " << passed << "\n"; // bool se imprime como 1 / 0
}

Un bool se imprime como 1 o 0 por defecto, no como true/false. Un char usa comillas simples - 'A' es un carácter, mientras que "A" (comillas dobles) es un literal de cadena, un tipo completamente distinto. Esos dos errores son extremadamente comunes al principio.

Los tamaños no son fijos

Esta es la mayor sorpresa para quien viene de lenguajes como Java. El estándar de C++ solo garantiza los tamaños mínimos y un orden relativo (short ≤ int ≤ long ≤ long long). El tamaño real depende de tu compilador y tu plataforma. Compruébalo siempre con sizeof:

#include <iostream>
using namespace std;

int main() {
    cout << "char:      " << sizeof(char)      << " byte\n";  // siempre 1
    cout << "short:     " << sizeof(short)     << " bytes\n";
    cout << "int:       " << sizeof(int)       << " bytes\n";
    cout << "long:      " << sizeof(long)      << " bytes\n";
    cout << "long long: " << sizeof(long long) << " bytes\n";
    cout << "double:    " << sizeof(double)    << " bytes\n";
}

En una compilación típica de Linux de 64 bits verás int = 4, long = 8. En Windows de 64 bits, sin embargo, long ocupa solo 4 bytes. Esa brecha de portabilidad es precisamente por la que no deberías escribir código que asuma que long es de 64 bits.

Cuando necesites un ancho exacto, recurre a los tipos enteros de ancho fijo de <cstdint>:

#include <iostream>
#include <cstdint>
using namespace std;

int main() {
    int8_t   a = -120;          // exactamente 8 bits, signed
    uint16_t b = 65000;         // exactamente 16 bits, unsigned
    int32_t  c = 2000000000;    // exactamente 32 bits
    int64_t  d = 9000000000LL;  // exactamente 64 bits, en todas las plataformas

    cout << (int)a << " " << b << " " << c << " " << d << "\n";
}

Usa int32_t/int64_t para formatos de archivo, protocolos de red o cualquier cosa que deba comportarse igual en todas las máquinas. Fíjate en la conversión (int)a - al enviar un tipo de 8 bits a un flujo se imprime como carácter, no como número, así que conviértelo primero.

Signed frente a unsigned

Cada tipo entero viene en dos variantes. Un tipo signed puede contener negativos; un tipo unsigned no, cambiando el rango negativo por un máximo positivo mayor. El int simple es signed por defecto.

#include <iostream>
#include <climits>
using namespace std;

int main() {
    unsigned int u = 0;
    u = u - 1;          // NO se convierte en -1
    cout << u << "\n";  // da la vuelta hasta 4294967295 (el máximo unsigned int)

    cout << "int max:  " << INT_MAX << "\n";
    cout << "uint max: " << UINT_MAX << "\n";
}

Restar a un 0 sin signo da la vuelta hacia un número positivo enorme en lugar de volverse negativo. Esto le pasa a la gente constantemente - sobre todo con size_t (un tipo unsigned) que devuelve .size():

vector<int> v = {1, 2, 3};
// PELIGRO: v.size() es unsigned. Si v está vacío, v.size() - 1 da la vuelta
// a un número gigantesco y el bucle se ejecuta casi para siempre.
for (size_t i = 0; i <= v.size() - 1; i++) { /* ... */ }

Prefiere i < v.size() (nunca <= size() - 1), o evita el problema por completo con un bucle for basado en rango.

El desbordamiento de enteros es comportamiento indefinido

A diferencia del giro de los unsigned (que está bien definido), el desbordamiento de enteros con signo es comportamiento indefinido en C++. El compilador puede hacer cualquier cosa - devolver basura, eliminar la comprobación al optimizar o fallar:

#include <iostream>
#include <climits>
using namespace std;

int main() {
    int maxInt = INT_MAX;            // 2147483647
    cout << maxInt << "\n";
    cout << maxInt + 1 << "\n";      // COMPORTAMIENTO INDEFINIDO - a menudo da la vuelta a negativo

    long long safe = (long long)maxInt + 1; // promociona antes de sumar
    cout << safe << "\n";            // 2147483648, correcto
}

La solución es la misma que para la trampa del desbordamiento en cualquier lenguaje: haz la aritmética en un tipo más ancho. Convierte un operando a long long antes del +, para que la suma ocurra en 64 bits. Convertir el resultado después es demasiado tarde - el desbordamiento ya ocurrió.

Elegir el tipo adecuado

Para la mayoría del código, los valores predeterminados van bien: int para números enteros, double para decimales. Recurre a otra cosa solo cuando tengas un motivo.

Tipo	Tamaño típico	Úsalo cuando
`int`	32 bits	El predeterminado para números enteros
`long long`	64 bits	Valores superiores a ~2 mil millones: marcas de tiempo, contadores grandes
`double`	64 bits	El predeterminado para decimales - buena precisión
`float`	32 bits	Arrays con poca memoria donde la precisión puede ceder
`bool`	1 byte	Una bandera true/false
`int32_t` / `int64_t`	exacto	Formatos multiplataforma, protocolos, manipulación de bits

Un par de trampas que conviene tener en cuenta. float tiene solo unos 7 dígitos decimales significativos, así que 0.1f + 0.2f no es exactamente 0.3 - prefiere double a menos que realmente necesites ahorrar memoria. Y char puede ser signed o unsigned según la plataforma, así que si haces aritmética con bytes en bruto, especifica signed char o unsigned char.

A continuación: La palabra clave auto

Escribir el tipo cada vez resulta tedioso y, a veces, el tipo es largo o difícil de nombrar. C++ deja que el compilador lo deduzca por ti con la palabra clave auto - auto x = 42; hace que x sea un int, y auto it = v.begin(); te ahorra escribir un tipo de iterador verboso. La siguiente página cubre cuándo auto hace el código más claro y cuándo oculta demasiado.

Preguntas frecuentes

¿Cuáles son los tipos de datos básicos en C++?

Los tipos fundamentales son los enteros (short, int, long, long long), los de coma flotante (float, double, long double), el tipo de carácter char y el tipo booleano bool. Cada tipo entero puede ser además signed o unsigned. Todo lo demás - std::string, los arrays, tus propias clases - se construye sobre estos.

¿Cuál es la diferencia entre int y long en C++?

Ambos almacenan números enteros, pero se garantiza que long sea al menos tan ancho como int (a menudo 64 bits en plataformas de 64 bits, pero solo 32 bits en Windows). El estándar solo fija los tamaños mínimos, así que para un ancho garantizado usa los tipos de ancho fijo de <cstdint> como int32_t e int64_t.

¿Cuánto ocupa un int en C++?

El estándar solo garantiza que int tenga al menos 16 bits, pero en prácticamente todos los equipos de escritorio y servidores modernos son 32 bits. Como los tamaños dependen de la plataforma, nunca lo des por sentado - imprime sizeof(int) para comprobarlo, o usa tipos de <cstdint> como int32_t cuando necesites un ancho exacto.

Conceptos relacionados