</>waridocu

C++

La Standard Library y tu primer main()

Qué es std::, qué hace #include <iostream>, y por qué tu main() se ve como se ve.

cppstandard-libraryiostreamnamespacesmain

Por qué esta página va antes que nada más

En ¿Qué es C++? viste este programa:

Ejemplo: Hola Mundo en C++cpp
#include <iostream>

int main() {
    std::cout << "Hola, mundo desde C++" << std::endl;
    return 0;
}

Cuatro cosas ahí dentro no son obvias si nunca escribiste C++: qué es #include <iostream>, qué es std::, qué es std::cout y por qué se usa << en vez de una función normal. Esta página responde exactamente eso, porque son la base para leer cualquier ejemplo de C++ que vengas a consultar después (incluyendo los de Dear ImGui).

La Standard Library, en una frase

La Standard Library (o STL en su parte de contenedores/algoritmos) es el conjunto de código que viene incluido con cualquier compilador de C++ conforme al estándar: entrada/salida, manejo de texto (std::string), estructuras de datos (std::vector, std::map…), utilidades genéricas, y más. No la escribes tú ni la instalas aparte: siempre está disponible, solo tienes que decirle al compilador qué parte quieres usar con un #include.

Nota

#include <iostream> no “importa una librería externa” en el sentido de instalar algo con un gestor de paquetes. Le dice al compilador: “copia aquí las declaraciones de entrada/salida de la Standard Library, que ya viene con tu instalación de C++”. Por eso el ejemplo de arriba compila sin instalar nada.

Namespaces y el prefijo std::

Un namespace (espacio de nombres) es una forma de agrupar nombres (de funciones, clases, variables) para que no choquen con otros que se llamen igual. Toda la Standard Library vive dentro del namespace std, así que para usar algo de ahí escribes std::algo, donde :: significa “dentro de”.

std::cout entonces se lee: “el cout que vive dentro del namespace std”. Si dos librerías distintas definieran cada una algo llamado cout, el prefijo std:: deja claro cuál quieres.

Advertencia

Vas a encontrar mucho código (sobre todo tutoriales viejos) que empieza con using namespace std; para no escribir std:: cada vez. Funciona, pero mezclado con proyectos grandes puede generar colisiones de nombres difíciles de rastrear. La práctica moderna recomendada es escribir std:: explícito, o como mucho hacer using std::cout; para los nombres puntuales que uses mucho en un archivo.

iostream: entrada y salida por consola

El header <iostream> declara los objetos para leer y escribir en la consola:

  • std::cout (“character output”): escribe hacia la salida estándar (normalmente, la terminal).
  • std::cin (“character input”): lee desde la entrada estándar (lo que el usuario tipea).
  • std::cerr: como cout, pero para mensajes de error (por convención, no se mezcla con la salida normal).

El operador << (“insertar hacia”) manda datos hacia cout; el operador >> (“extraer desde”) saca datos desde cin. No son operadores especiales de I/O del lenguaje: son los operadores de desplazamiento de bits (<<, >>) sobrecargados para que, cuando el operando izquierdo es un stream, hagan otra cosa. Por ahora basta con leerlos como “flecha que indica hacia dónde va el dato”.

Ejemplo: leer un nombre y saludarcpp
#include <iostream>
#include <string>

int main() {
    std::string nombre;

    std::cout << "¿Cómo te llamas? ";
    std::cin >> nombre;

    std::cout << "Hola, " << nombre << "! Bienvenido a C++" << std::endl;
    return 0;
}

Fíjate que std::cout << "Hola, " << nombre << "!..." encadena varios << seguidos: cada uno “inserta” un dato más en la misma línea de salida, de izquierda a derecha.

std::endl frente a "\n"

Ambos terminan la línea actual e imprimen un salto de línea, pero no son lo mismo:

Tip

std::endl además fuerza un flush del buffer de salida (obliga a que lo que estaba esperando para imprimirse se imprima ya). Eso tiene un costo de rendimiento diminuto pero real. Para código de uso normal, "\n" alcanza y es más barato; reserva std::endl para cuando de verdad necesitas garantizar que algo se vea en pantalla de inmediato (por ejemplo, justo antes de que el programa pueda crashear).

Ejemplo: "\n" vs std::endlcpp
std::cout << "Esto imprime igual" << "\n";      // salto de línea simple
std::cout << "Esto también, pero con flush" << std::endl; // salto de línea + flush

De vuelta a tu main()

Con esto, el main() del principio ya se lee completo:

  1. #include <iostream> trae las declaraciones de cout/cin/cerr de la Standard Library.
  2. std::cout es “el objeto de salida que vive en el namespace std”.
  3. << empuja el texto "Hola, mundo desde C++" hacia esa salida.
  4. std::endl termina la línea y fuerza el flush.
  5. return 0; le dice al sistema operativo que el programa terminó sin errores (por convención, 0 significa éxito).

De aquí en más, cada vez que veas std::algo en un ejemplo (std::string, std::vector, o más adelante ImGui::Begin, que sigue la misma idea de namespace pero para la librería Dear ImGui en vez de la Standard Library), ya sabes qué pregunta hacerte: ¿qué header lo trae, y qué namespace lo agrupa?

Con esta base, ya puedes seguir a ¿Qué es Dear ImGui? — que usa el mismo patrón de namespace (ImGui::) aplicado a su propia librería en vez de a la Standard Library.