1.07 · Estructura de un Programa: Hola Mundo y Entrada/Salida

🎯 Objetivo de aprendizaje

Al terminar este tema vas a poder:

1. Identificar las 4 partes de un programa en C++ (directivas, espacios de nombres, función main, instrucciones) y explicar qué hace cada una.
2. Escribir el programa "Hola Mundo" en C++, Java y Python, y compilarlo/ejecutarlo correctamente.
3. Leer datos del usuario con cin (C++), Scanner (Java) e input (Python), validando tipos cuando sea necesario.
4. Imprimir datos en pantalla con formato profesional: cout con manipuladores, System.out.printf, f-strings de Python.
5. Usar las secuencias de escape (\n, \t, \\, \") y entender su propósito.
6. Comentar tu código siguiendo las buenas prácticas (cuándo comentar, qué comentar, qué NO comentar).
7. Depurar errores comunes de compilación y ejecución con ayuda del IDE y la IA.

Este es el primer tema donde escribes programas completos y funcionales. A partir de aquí, cada tema tiene código real que corre.

🧠 Teoría y conceptos — 1.7.1 — Las 4 partes de un programa en C++

Anatomía de un programa C++

Todo programa en C++ tiene 4 partes fundamentales. Vamos a verlas con un ejemplo simple:

// 1. DIRECTIVAS DEL PREPROCESADOR

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

// 2. FUNCIÓN PRINCIPAL

int main() {

// 3. DECLARACIONES DE VARIABLES

string nombre;

int edad;

// 4. INSTRUCCIONES (cuerpo del programa)

cout << "¿Cómo te llamas? ";
cin >> nombre;
cout << "¿Cuántos años tienes? ";
cin >> edad;
cout << "Hola " << nombre << ", tienes " << edad << " años." << endl;
return 0;

}

Parte 1 — Directivas del preprocesador

Las directivas son órdenes que se ejecutan ANTES de la compilación, en una fase llamada "preprocesamiento". Empiezan con #.

Librerías más usadas:

Parte 2 — using namespace std;

Qué es: un espacio de nombres es como un "apellido" para las funciones. En C++, las funciones estándar viven en el espacio std (de "standard"). Si escribes using namespace std;, le dices al compilador "cuando vea cout, es std::cout".
Alternativa: puedes NO usar using namespace std; y prefijar todo con std:::
#include <iostream>
int main() {
std::cout << "Hola" << std::endl;
return 0;

}

¿Por qué en este curso usamos `using namespace std;`? Para principiantes hace el código más corto y legible. En programas profesionales se prefiere prefijar con std:: para evitar conflictos de nombres.

Parte 3 — Función main()

`main` es el punto de entrada del programa. Cuando ejecutas un programa, el sistema operativo llama a main y ejecuta lo que está dentro de sus llaves {}.
int main() {

// instrucciones

return 0;

}

Parte 4 — Instrucciones (cuerpo del programa)

Dentro de main van las instrucciones que tu programa ejecuta, una por una, de arriba hacia abajo. Cada instrucción termina con ;.

cout << "Hola";  // instrucción 1

int x = 5; // instrucción 2

x = x + 1; // instrucción 3

El ; es como el punto final de una oración: marca el final de una instrucción. Sin `;`, el compilador da error.

1.7.2 — Hola Mundo en C++: compilar y ejecutar

El programa más famoso de la historia

#include <iostream>
using namespace std;
int main() {
cout << "¡Hola, mundo!" << endl;
return 0;

}

Compilación paso a paso

Paso 1: Crea el archivo.

1. Abre VS Code.
2. Ve a tu carpeta de proyecto: C:\Dev\curso-programacion-junior\capitulo-01-fundamentos\proyectos\tema-1-7-hola-mundo\.
3. Ctrl + N para crear un archivo nuevo.
4. Escribe el código (no lo copies, escríbelo para que tu cerebro registre la sintaxis).
5. Ctrl + S para guardar. Nómbralo main.cpp (la extensión .cpp es crucial).

Paso 2: Compila.

1. Abre la terminal integrada (Ctrl + ñ).
2. Verifica que estás en la carpeta correcta (pwd en Mac/Linux, cd en Windows).
3. Ejecuta:

g++ main.cpp -o hola.exe

Si todo va bien, no aparece ningún mensaje y vuelve al prompt. Si hay errores, el compilador te dice qué está mal (lo veremos en 1.7.8).

Paso 3: Ejecuta.

.\hola.exe

Deberías ver:

¡Hola, mundo!

Variaciones del Hola Mundo

Variación 1 — Con salto de línea explícito:

cout << "¡Hola, mundo!" << endl;

endl inserta un salto de línea y vacía el buffer.

Variación 2 — Con `\n` en lugar de `endl`:

cout << "¡Hola, mundo!\n";

\n también inserta un salto de línea, pero NO vacía el buffer (más rápido en programas grandes).

Variación 3 — Múltiples líneas:

cout << "Línea 1" << endl;
cout << "Línea 2" << endl;
cout << "Línea 3" << endl;

Variación 4 — Concatenación con `+` (no funciona en C++):

// ❌ ESTO NO FUNCIONA EN C++

cout << "Hola" + "mundo";  // Error de compilación

En C++ NO puedes concatenar strings con +. Debes usar <<:

// ✅ Correcto en C++

cout << "Hola" << " " << "mundo" << endl;

O usar string y +:

string saludo = string("Hola") + " " + "mundo";

cout << saludo << endl;

1.7.4 — Salida formateada: cout, printf, f-strings

Por qué importa el formato

Un programa que imprime "El resultado es 5.000000" es funcional. Un programa que imprime "El resultado es 5.00" es profesional. La diferencia es el formato.

Formato con cout en C++ (manipuladores)

#include <iostream>
#include <iomanip>  // para setw, setprecision, fixed
using namespace std;
int main() {

double pi = 3.14159265358979;

int numero = 42;

// Formato por defecto

cout << pi << endl;        // 3.14159
cout << numero << endl;     // 42

// Con setprecision: 2 dígitos significativos

cout << setprecision(2) << pi << endl;  // 3.1

// Con fixed: notación decimal fija

cout << fixed << setprecision(2) << pi << endl;  // 3.14

// Con setw: ancho fijo (alinea columnas)

cout << setw(10) << numero << endl;     // "        42"
cout << setw(10) << 1234 << endl;       // "      1234"
return 0;

}

Formato con printf en C++ (estilo C)

printf es la forma "vieja escuela" de formatear, heredada de C. Es muy poderosa pero la sintaxis es más difícil.
#include <cstdio>
int main() {

int edad = 25;

double pi = 3.14159;

char inicial = 'J';

// %d = entero, %f = flotante, %c = carácter, %s = string

printf("Edad: %d años\n", edad);
printf("Pi: %.2f\n", pi);          // 2 decimales
printf("Inicial: %c\n", inicial);
printf("Hola %s, tienes %d años\n", "Juan", edad);
return 0;

}

Especificadores comunes:

Formato con System.out.printf en Java

Igual que en C++:

public class Formato {
public static void main(String[] args) {

int edad = 25;

double pi = 3.14159;

String nombre = "Ana";

System.out.printf("Hola %s, tienes %d años%n", nombre, edad);
System.out.printf("Pi: %.2f%n", pi);

}

}

Formato con f-strings en Python (la forma moderna)

nombre = "Ana"

edad = 25

pi = 3.14159

# f-string: anteponer f, usar {} para variables
print(f"Hola {nombre}, tienes {edad} años")  # Hola Ana, tienes 25 años
print(f"Pi: {pi:.2f}")                       # Pi: 3.14
print(f"En 10 años tendrás {edad + 10} años")  # Cálculo dentro de {}

Especificadores de formato en f-strings:

1.7.5 — Secuencias de escape y caracteres especiales

Las secuencias de escape más comunes

Una secuencia de escape es un par de caracteres que empiezan con \ y representan un carácter especial.

Ejemplo: imprimir un menú con bordes

cout << "╔════════════════════╗" << endl;
cout << "║  Menú Principal    ║" << endl;
cout << "╠════════════════════╣" << endl;
cout << "║  1. Opción A       ║" << endl;
cout << "║  2. Opción B       ║" << endl;
cout << "║  3. Salir          ║" << endl;
cout << "╚════════════════════╝" << endl;

Para que los caracteres de borde se vean bien en tu terminal, asegúrate de que la fuente soporte UTF-8 (las fuentes modernas de Windows Terminal, VS Code y Mac Terminal sí lo hacen).

Cadenas raw (sin procesar escapes) en Python

En Python puedes usar cadenas raw (crudas) con el prefijo r, que NO procesan las secuencias de escape:

r"C:\Users\Juan\nombre.txt" # La \n NO se interpreta como salto

# Resultado literal: C:\Users\Juan\nombre.txt

Útil para rutas de archivos y expresiones regulares.

Caracteres Unicode en strings

Los strings pueden contener caracteres Unicode (emojis, acentos, símbolos):

cout << "Año 2024 🚀" << endl;  // C++20 y fuentes Unicode
cout << "Pi: \u03C0" << endl;    // π en Unicode escape

print("Año 2024 🚀") # Python 3, fuente con soporte Unicode

print("Pi: \u03C0") # π

1.7.6 — Lectura de datos: cin, Scanner, input

Lectura con cin en C++

#include <iostream>
#include <string>
using namespace std;
int main() {

string nombre;

int edad;

double estatura;

cout << "Nombre: ";
cin >> nombre;
cout << "Edad: ";
cin >> edad;
cout << "Estatura (m): ";
cin >> estatura;
cout << "Hola " << nombre << ", tienes " << edad

<< " años y mides " << estatura << " m." << endl;

return 0;

}

Cómo funciona `cin >> variable`:

1. Espera a que el usuario escriba algo y presione Enter.
2. Lee los caracteres hasta encontrar un espacio o salto de línea.
3. Convierte el texto al tipo de la variable (si puede).
4. Si no puede convertir (ej: letras en un int), la variable queda en estado de error.

Limitación importante: cin >> no lee espacios. Si quieres leer una línea completa (con espacios), usa getline:

string nombreCompleto;

cout << "Nombre completo: ";
getline(cin, nombreCompleto);

Lectura con Scanner en Java

import java.util.Scanner;
public class Lectura {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Nombre: ");

String nombre = sc.nextLine(); // Lee línea completa

System.out.print("Edad: ");

int edad = sc.nextInt(); // Lee entero

System.out.print("Estatura: ");

double estatura = sc.nextDouble();

System.out.println("Hola " + nombre + ", tienes " + edad

+ " años y mides " + estatura + " m.");

}

}

Métodos principales de Scanner:

Lectura con input en Python

nombre = input("Nombre: ") # Lee string

edad = int(input("Edad: ")) # Lee y convierte a int

estatura = float(input("Estatura: ")) # Lee y convierte a float

print(f"Hola {nombre}, tienes {edad} años y mides {estatura} m.")

Importante: input SIEMPRE devuelve un string. Si quieres número, tienes que convertir explícitamente con int() o float().

Validación de entrada: el caso que nadie te cuenta

¿Qué pasa si el usuario escribe "veinte" cuando le pides la edad? El programa revienta (en C++/Java) o da error (en Python).

En C++ (con validación):

int edad;

cout << "Edad: ";
cin >> edad;
if (cin.fail()) {
cout << "Error: no ingresaste un número válido." << endl;
cin.clear();           // Limpia el estado de error
cin.ignore(10000, '\n');  // Descarta el resto de la línea

}

En Python (con validación):

while True:

try:

edad = int(input("Edad: "))

if edad < 0 or edad > 150:

print("Edad fuera de rango")

continue

break # Si todo OK, sale del bucle

except ValueError:

print("Error: no ingresaste un número válido")

En Java (con validación):

// Más complejo: usa try-catch y métodos de Scanner

1.7.7 — Comentarios: cuándo, qué y cómo

Los 3 tipos de comentarios

Ejemplos en los 3 lenguajes

C++:

// Esto es un comentario de una línea

/*

Esto es un comentario

de varias líneas

*/

/**

• @brief Calcula el área de un rectángulo
• @param base Base del rectángulo
• @param altura Altura del rectángulo
• @return Área calculada

*/

double calcularArea(double base, double altura) {

return base * altura;

}

Java:

// Comentario de una línea

/*

Comentario de varias líneas

*/

/**

• Suma dos números enteros.
• @param a Primer sumando
• @param b Segundo sumando
• @return La suma de a + b

*/

public static int sumar(int a, int b) {
return a + b;

}

Python:

# Comentario de una línea

"""

Docstring de varias líneas.

Se usa para documentar funciones, clases o módulos.

"""

def sumar(a, b):

"""Suma dos números y devuelve el resultado."""

return a + b

Qué comentar y qué NO comentar

✅ SÍ comentar:

• La intención del código (por qué lo haces, no qué hace).
• Decisiones de diseño no obvias.
• Funciones y clases (qué hacen, qué reciben, qué devuelven).
• Advertencias o cosas a tener en cuenta.
• Expresiones regulares o algoritmos complejos.

❌ NO comentar:

• Cosas obvias (x = x + 1; // incrementa x).
• Código muerto o comentado.
• Lo que dice el código (i++; // incrementa i).

El olor del código mal comentado

// ❌ MAL: comenta lo obvio

i++; // incrementa i en 1

cout << x;  // imprime x

// ✅ BIEN: comenta la intención

i++; // Saltamos al siguiente alumno

cout << x;  // Mostramos la calificación para que el usuario la vea

⚠️ Errores típicos — 1.7.8 — Errores comunes de compilación y cómo resolverlos

Los 3 tipos de errores

Los 10 errores de compilación más comunes en C++ (principiantes)

Cómo leer un mensaje de error

El compilador te da MUCHA información. Aprende a leerla:

main.cpp:7:5: error: 'cot' was not declared in this scope

7 | cot << "Hola" << endl;

| ^~~

El flujo de resolución de un error

1. Lee el mensaje de error completo.
2. Identifica el archivo y la línea.
3. Ve a esa línea en tu código.
4. Compara con la teoría del manual.
5. Si no lo entiendes, cópialo a Google (en español o inglés).
6. Si no lo encuentras, pregúntale a la IA con un prompt específico.
7. Si nada funciona, pídele ayuda al profesor o a un compañero.

❌ Errores típicos del razonamiento

Error 1: "Mi programa no funciona, no sé por dónde empezar"

Idea equivocada: "Llevo 2 horas atorado. Voy a empezar de cero."

Realidad: empezar de cero es perder el avance. Mejor:

1. Lee el mensaje de error.
2. Identifica la línea.
3. Comenta esa línea con // y prueba sin ella.
4. Si el programa ahora funciona, sabes que el error está ahí.
5. Compara con la teoría.

Cómo evitarlo: depuración sistemática, no desesperación.

Error 2: "El programa compila, entonces está bien"

Idea equivocada: "Ya no hay errores rojos en el IDE, debe funcionar."

Realidad: compilar es solo el primer paso. Que el programa ejecute sin errores NO significa que haga lo correcto. La verificación de la lógica es tu trabajo.

Cómo evitarlo: traza con datos de prueba que ya conoces el resultado. Si no coincide, hay error lógico.

Error 3: "El usuario siempre va a meter los datos correctos"

Idea equivocada: "Mi programa pide edad, el usuario va a meter 25. No necesito validar."

Realidad: los usuarios meten "veinticinco", "-5", "0", "9999", "asdf", o nada (solo Enter). Tu programa DEBE manejar esos casos.

Cómo evitarlo: valida SIEMPRE la entrada del usuario. Es una de las skills más importantes del programador profesional.

Error 4: "Lo importante es que funcione, no cómo se ve"

Idea equivocada: "Si imprime el resultado, está bien. El formato no importa."

Realidad: un programa que imprime "elresultadoes5.000000" es técnicamente correcto pero profesionalmente inaceptable. El formato de salida es parte de la calidad.

Cómo evitarlo: desde el primer programa, formatea la salida con decimales, saltos de línea, y mensajes claros.

Error 5: "Si la IA me corrigió, ya está bien"

Idea equivocada: "Le pasé mi código a Copilot, me dio la versión corregida, listo."

Realidad: la IA puede darte una versión que compila y ejecuta, pero que tiene los MISMOS errores lógicos que tu versión original, solo "reorganizados".

Cómo evitarlo: siempre prueba el código corregido con datos que ya conoces. Si el resultado no coincide, vuelve a la versión original y busca tú mismo.

🤖 IA como copiloto — 🤖 AI Mission 1.7 — Debugging con IA

Regla de los 3 minutos: primero intenta resolver el error por tu cuenta. Si después de 3 minutos no avanzas, primero relee la teoría, luego consulta tu cuaderno, luego consulta la IA.

Prompts sugeridos

Prompt 1 — Interpretar un error de compilación:

"El compilador g++ me da este error al compilar mi código: '[pega el mensaje]'. El código que lo causa es este: '[pega el código]'. NO me corrijas el código. Solo dime: (1) qué significa el error, (2) qué tipo de error es, (3) qué tengo que cambiar (sin darme el código). Máximo 150 palabras."

Prompt 2 — Encontrar un error lógico:

"Mi programa en C++ debería hacer X pero hace Y. Te pego el código: '[código]'. NO me lo corrijas. Solo dime: (1) qué hace línea por línea, (2) en qué línea está el problema, (3) por qué. Máximo 200 palabras."

Prompt 3 — Comparar 2 versiones:

"Te voy a pegar 2 versiones de un programa en C++ que deberían hacer lo mismo. Una funciona y la otra no. NO me digas cuál es cuál. Solo dime: ¿qué hace cada una? ¿Qué diferencia hay entre ellas? Máximo 150 palabras."

Prompt 4 — Optimizar:

"Mi programa en C++ funciona pero quiero que sea más legible. Te pego el código: '[código]'. NO me des el código corregido. Solo dime: (1) qué partes son difíciles de leer, (2) qué buenas prácticas no estoy siguiendo, (3) qué nombre de variable podría mejorar. Máximo 200 palabras."

🧪 Laboratorio — 🧪 LAB 1.7 — 6 programas reales

Tiempo total: 2 h 30 min | Entregable: 6 programas funcionando, con código fuente, capturas de pantalla y prueba con datos.

Ejercicio 1 — Hola Mundo personalizado (básico, 15 min)

Enunciado. Crea un programa que pida al usuario su nombre, su edad y su ciudad, e imprima un mensaje personalizado: "Hola [nombre], tienes [edad] años y vives en [ciudad]. Bienvenido al curso de programación."

Hazlo en los 3 lenguajes (C++, Java, Python).

Criterio de éxito: los 3 programas compilan, ejecutan y muestran el mensaje correcto con datos de prueba.

Rúbrica (10 pts): 3 pts por cada versión + 1 pt por formato claro.

Ejercicio 2 — Calculadora de IMC con formato (básico, 25 min)

Enunciado. El programa de IMC que vimos en la comparación, ahora ampliado:

• Pide nombre, peso, estatura, edad.
• Calcula IMC.
• Muestra: nombre, peso, estatura, IMC (con 2 decimales), clasificación (bajo peso, normal, sobrepeso, obesidad).
• Si la edad es menor de 18 o mayor de 100, muestra un mensaje: "Esta calculadora está diseñada para adultos entre 18 y 100 años."

Criterio de éxito: valida la edad, formatea la salida correctamente.

Rúbrica (10 pts): IMC correcto (3 pts) + formato (2 pts) + clasificación (2 pts) + validación (3 pts).

Ejercicio 3 — Conversor de unidades (intermedio, 30 min)

Enunciado. Crea un programa que sea un conversor de unidades con menú:

=== Conversor de Unidades ===

1. Kilómetros a millas
2. Celsius a Fahrenheit
3. Kilogramos a libras
4. Salir

Opción: _

Según la opción, pide el dato y muestra la conversión. Si la opción es 4, termina. Si es inválida, muestra error.

Fórmulas:

• 1 milla = 1.60934 km
• F = (C × 9/5) + 32
• 1 kg = 2.20462 lb

Criterio de éxito: maneja las 4 opciones, repite hasta que el usuario elija salir.

Rúbrica (10 pts): menú (2 pts) + 3 conversiones (6 pts) + bucle (2 pts).

Ejercicio 4 — Tabla de multiplicar personalizada (intermedio, 25 min)

Enunciado. Pide un número N al usuario y muestra su tabla de multiplicar del 1 al 10, formateada como una tabla con bordes.

Ejemplo para N=7:

╔═══════════════════════════════╗

║ Tabla de multiplicar del 7 ║

╠═══════════════════════════════╣

║ 7 × 1 = 7 ║

║ 7 × 2 = 14 ║

║ ... ║

║ 7 × 10 = 70 ║

╚═══════════════════════════════╝

Criterio de éxito: la tabla se ve profesional con los bordes y alineación.

Rúbrica (10 pts): cálculo correcto (4 pts) + formato con bordes (3 pts) + alineación (3 pts).

Ejercicio 5 — Validador de entrada robusto (avanzado, 35 min)

Enunciado. Crea un programa que pida al usuario su edad y valide:

• Que sea un número entero (no letras).
• Que esté entre 0 y 150.
• Si no, vuelve a pedir hasta que sea válida.

Pide después su nombre (puede tener espacios) y valida que no esté vacío.

Criterio de éxito: rechaza entradas inválidas con mensajes claros, no se cae con entradas erróneas.

Rúbrica (10 pts): validación de tipo (3 pts) + rango (2 pts) + nombre (2 pts) + mensajes (3 pts).

Ejercicio 6 — Programa completo con todo (avanzado, 30 min)

Enunciado. Elige UNA de estas opciones y crea un programa completo que use TODO lo aprendido:

• Opción A: Agenda de contactos (alta, baja, búsqueda de 5 contactos).
• Opción B: Sistema de calificaciones (captura N alumnos con 3 calificaciones, muestra promedios).
• Opción C: Cajero automático (consultar saldo, depositar, retirar, con validación).

Criterio de éxito: el programa tiene menú, valida entradas, persiste los datos en memoria, y se puede salir limpiamente.

Rúbrica (10 pts): funcionalidad (3 pts) + menú (2 pts) + validación (2 pts) + formato (1 pt) + documentación (2 pts).

Ejercicio bonus — Calculadora de tiempo (avanzado, opcional, 30 min)

Enunciado. Pide al usuario un número de segundos y conviértelo a formato "X horas, Y minutos, Z segundos". Ejemplo: 3661 segundos = "1 hora, 1 minuto, 1 segundo".

Rúbrica bonus (5 pts): 3 pts por el cálculo + 2 pts por el formato.

🎯 Cierre del tema

Lo que aprendiste hoy:

• Las 4 partes de un programa en C++ y su propósito.
• Hola Mundo en C++, Java y Python.
• Salida formateada con cout, printf y f-strings.
• Secuencias de escape y caracteres Unicode.
• Lectura de datos del usuario con cin, Scanner, input.
• Cómo comentar bien el código.
• Los errores de compilación más comunes y cómo resolverlos.

Lo que sigue: en el Tema 1.8 — Buenas Prácticas, Git Básico y Clean Code Inicial (6h), el último tema antes del Boss 1. Vas a aprender las reglas de oro del código limpio, cómo usar Git para versionar tus proyectos, y las convenciones profesionales que diferencian a un junior de otro. Con esto estarás listo para el Boss 1: Calculadora de Calificaciones.

Antes de seguir, asegúrate de tener en tu cuaderno:

• [ ] 6 programas del LAB 1.7 funcionando.
• [ ] Tabla comparativa de "Hola Mundo" en C++/Java/Python.
• [ ] Los 10 errores de compilación comunes con ejemplos.
• [ ] Glosario con: directivas, preprocesador, namespace, main, return, cout, cin, getline, endl, \n, f-string, Javadoc.

XP obtenida al completar este tema: 100 base + 30 por LAB (6 programas) + 20 por Quest = 150 XP. Insignia desbloqueada al cerrar el capítulo: Code Caster (parcial).

*"El código se lee más veces de las que se escribe. Optimiza para el lector, no para el compilador."* — De la introducción de este manual.

Fin del Tema 1.7

📝 Quest · Cuestionario — 📝 Quest — Reactivos para autoevaluación

Sección A · Opción múltiple

Elige la opción correcta (A, B, C o D). Las respuestas están en la sección Respuestas modelo.

1. ¿Cuál es la función de punto de entrada en C++?
   • start()
   • main()
   • init()
   • begin()
2. En C++, ¿qué hace std::cout?
   • Lee entrada
   • Escribe a la salida estándar
   • Compila
   • Crea un archivo
3. ¿Cómo se importa la biblioteca iostream en C++?
   • #include <iostream>
   • import iostream
   • use iostream
   • include "iostream"
4. ¿Qué hace std::endl?
   • Termina el programa
   • Salto de línea y vacía el buffer
   • Lee una línea
   • Abre un archivo
5. En C++, ¿cómo se lee un número entero de consola?
   • scanf("%d", &x)
   • std::cin >> x
   • read x
   • input(x)
6. ¿Qué es el "Hola Mundo" en C++?
   • Hola
   • El primer programa típico: imprimir Hola Mundo
   • Un virus
   • Un juego
7. ¿Qué hace using namespace std;?
   • Crea un namespace
   • Evita escribir std:: antes de cout, cin, etc.
   • Compila
   • Ejecuta
8. En Java, ¿cuál es el equivalente a main() de C++?
   • start()
   • public static void main(String[] args)
   • init()
   • begin()
9. En Python, ¿cuál es la función de entrada típica?
   • start()
   • __main__ / if __name__ == "__main__"
   • public main()
   • func main()
10. En JavaScript, ¿qué función es el punto de entrada en el navegador?
    • start()
    • No tiene punto de entrada único (event-driven)
    • public main()
    • func main()

Sección B · Preguntas abiertas

Desarrolla tu respuesta en al menos 3 líneas. Compara con la respuesta modelo después de escribir.

1. Explica qué hace cada parte de un programa "Hola Mundo" en C++: include, using, main, cout.
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
2. Compara el Hola Mundo en C++, Java y Python. ¿Qué diferencias notaste?
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
3. ¿Por qué los Hola Mundo son importantes al aprender un nuevo lenguaje o framework?
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…