1.05 · Constantes, Variables, Tipos de Datos y Operadores

🎯 Objetivo de aprendizaje

Al terminar este tema vas a poder:

1. Distinguir entre constante y variable, y decidir cuándo usar cada una.
2. Declarar variables en C++, Java y Python siguiendo la sintaxis correcta de cada lenguaje.
3. Identificar los tipos de datos primitivos (entero, flotante, carácter, booleano, cadena) y elegir el más adecuado para cada situación.
4. Aplicar los 3 tipos de operadores (aritméticos, relacionales, lógicos) en expresiones correctas.
5. Entender la precedencia de operadores y usar paréntesis para evitar ambigüedades.
6. Convertir entre tipos de datos (casting) cuando sea necesario.
7. Aplicar buenas prácticas de nomenclatura de variables y constantes.

A partir de este tema, vamos a escribir código real en C++ (principal), con ejemplos comparativos en Java y Python. Si no tienes el IDE listo, ve al Tema 1.6 en paralelo y vuelve aquí cuando lo tengas.

🧠 Teoría y conceptos — 1.5.1 — Constantes y variables: qué son, en qué se diferencian

Variable: una cajita con nombre

Una variable es un espacio en la memoria de la computadora que tiene un nombre y guarda un valor que puede cambiar durante la ejecución del programa.

edad = 25 // La caja "edad" contiene 25

edad = 26 // Ahora la caja "edad" contiene 26

Constante: una cajita con valor fijo

Una constante es un espacio en la memoria que tiene un nombre y guarda un valor que NO cambia durante la ejecución del programa.

Analogía: una constante es como una placa de metal grabada. Una vez que se graba el texto, no se puede cambiar. Sigue diciendo lo mismo durante toda la vida del programa.

PI = 3.14159 // PI siempre vale 3.14159

VELOCIDAD_LUZ = 299792458 // en m/s

Las 3 diferencias clave

Cuándo usar cada una

Usa variable cuando:

• El valor puede cambiar (contadores, acumuladores, datos del usuario).
• El valor depende de condiciones externas (entradas, archivos, red).

Usa constante cuando:

• El valor es fijo por las matemáticas o la física (PI, E, GRAVEDAD).
• El valor es un código o identificador que no debe cambiar (MAX_INTENTOS = 3).
• El valor es una configuración del sistema (TASA_IVA = 0.16, MAX_USUARIOS = 100).

Declaración de variables y constantes en los 3 lenguajes

En C++:

// Variable: tipo nombre = valor;

int edad = 25;

float estatura = 1.75f;

double peso = 70.5;

// Constante: const tipo nombre = valor;

const double PI = 3.14159;

const int MAX_INTENTOS = 3;

En Java:

// Variable: tipo nombre = valor;

int edad = 25;

float estatura = 1.75f;

double peso = 70.5;

// Constante: final tipo nombre = valor;

final double PI = 3.14159;

final int MAX_INTENTOS = 3;

En Python:

# Variable: nombre = valor (el tipo se infiere)

edad = 25

estatura = 1.75

peso = 70.5

# Constante: por convención, nombre en MAYÚSCULAS

PI = 3.14159

MAX_INTENTOS = 3

Nota para Python: Python no tiene constantes verdaderas. Por convención, si una variable está escrita en MAYÚSCULAS, los programadores la tratan como constante y no la modifican. Pero el lenguaje no impide cambiarla. En cambio, en C++ y Java, las constantes (`const` y `final`) están protegidas por el compilador.

Buenas prácticas

1. Los nombres de constantes van en MAYÚSCULAS_CON_GUIONES. Ej: MAX_INTENTOS, PI, VELOCIDAD_LUZ.
2. Los nombres de variables van en minúsculas_con_guiones (snake_case en Python) o camelCase (C++/Java). Ej: edadUsuario, calificacionPromedio.
3. Declara las constantes al inicio del archivo, junto con las librerías. Así es fácil encontrarlas y modificarlas.
4. Inicializa las variables al declararlas (asígnales un valor desde el inicio). Evita variables "vacías" que pueden contener basura de memoria.

1.5.2 — Identificadores: reglas para nombrar variables y constantes

Qué es un identificador

Un identificador es el nombre que le pones a una variable, constante, función, clase u otro elemento del programa. Es la forma en que te refieres a ese elemento en el código.

Reglas obligatorias (sintaxis)

1. Solo puede contener:

• Letras (a-z, A-Z)
• Dígitos (0-9)
• Guión bajo (_)

1. Debe empezar con:

• Una letra
• O un guión bajo (_)

1. NO puede:

• Empezar con un dígito.
• Contener espacios.
• Contener caracteres especiales (!, @, #, $, %, etc.).
• Ser una palabra reservada del lenguaje (if, for, while, int, class, etc.).

Ejemplos válidos e inválidos

Convenciones de nomenclatura (estilo)

Aunque no son obligatorias por el compilador, los equipos de desarrollo las siguen para mantener el código legible.

Reglas de oro para nombrar bien

1. Nombres descriptivos, no crípticos. edad mejor que e, calificacionPromedio mejor que cp.
2. Evita nombres de una sola letra (excepto para variables de bucles como i, j, k).
3. Usa el mismo idioma en todo el proyecto. En este curso usamos español: edadUsuario, calificacionPromedio.
4. Nombres en singular para un solo objeto, en plural para colecciones. estudiante (uno), estudiantes (lista).
5. Los booleanos empiezan con `es`, `tiene`, `puede`, `debe`. esValido, tienePermisos, puedeEditar, debePagar.

1.5.3 — Tipos de datos primitivos: entero, flotante, carácter, booleano

Qué es un tipo de dato

Un tipo de dato define qué clase de información puede guardar una variable: números enteros, números con decimales, un carácter, verdadero/falso, etc. El tipo también define cuánta memoria se reserva y qué operaciones se pueden hacer con ese dato.

Los 5 tipos primitivos fundamentales

Tipos primitivos en C++

C++ tiene los tipos más variados de los 3 lenguajes. Aquí están los principales:

bool esValido = true;

char inicial = 'A';

int edad = 25;

short dia = 15;

long poblacion = 126000000L;

long long distancia = 299792458LL;

float estatura = 1.75f;

double pi = 3.14159265358979;

long double piExtendido = 3.141592653589793238L;

Tipos primitivos en Java

Java tiene menos tipos que C++ pero más que Python:

boolean esValido = true;

char inicial = 'A';

byte edadByte = 25;

short edadShort = 25;

int edad = 25;

long poblacion = 126000000L;

float estatura = 1.75f;

double pi = 3.14159265358979;

Tipos primitivos en Python

Python es el más simple: solo tiene 4 tipos numéricos principales (los demás son objetos):

es_valido = True

edad = 25

estatura = 1.75

poblacion = 126000000 # Python no distingue int de long

pi = 3.141592653589793238 # float, ~15 dígitos

Nota importante: Python no requiere declarar el tipo. El tipo se infiere del valor. C++ y Java sí requieren declaración explícita.

Tabla comparativa de tipos

Cómo elegir el tipo correcto

Reglas prácticas:

1. Para números enteros pequeños (contadores, edades, días del mes): usa int.
2. Para números enteros muy grandes (población, dinero en centavos, distancia): usa long o long long.
3. Para números con decimales (precios, promedios, mediciones científicas): usa double (más preciso que float).
4. Para un solo carácter (inicial, opción de menú, letra): usa char.
5. Para verdadero/falso (condiciones, estados): usa bool.
6. Para texto (nombres, mensajes): usa String (o std::string en C++).

1.5.4 — Cadenas de caracteres (strings): la excepción a los primitivos

Qué es un string

Un string (o cadena de caracteres) es una secuencia de cero o más caracteres tratados como un solo valor. Ejemplos: "Hola", "123", "" (cadena vacía), "Juan Pérez".

Importante: en C++ y Java, el string NO es un tipo primitivo, sino un tipo de referencia (una clase). En Python, el string es un tipo built-in (incorporado) pero tampoco es primitivo puro.

Strings en C++

#include <string>  // Librería obligatoria

std::string nombre = "Juan";

std::string saludo = "Hola, mundo";

std::string vacio = "";

// Concatenación con +

std::string completo = "Hola, " + nombre; // "Hola, Juan"

Strings en Java

String nombre = "Juan";

String saludo = "Hola, mundo";

String vacio = "";

// Concatenación con +

String completo = "Hola, " + nombre; // "Hola, Juan"

// IMPORTANTE: para leer del usuario se usa Scanner

import java.util.Scanner;
Scanner sc = new Scanner(System.in);

String nombreUsuario = sc.nextLine();

Strings en Python

nombre = "Juan"

saludo = "Hola, mundo"

vacio = ""

# Concatenación con +

completo = "Hola, " + nombre # "Hola, Juan"

# f-strings (la forma moderna recomendada)

edad = 25

mensaje = f"Tengo {edad} años"  # "Tengo 25 años"

El carácter de escape \

Algunos caracteres no se pueden escribir directamente en una cadena. Para incluirlos, usamos el carácter de escape \ seguido de un código:

Operaciones básicas con strings

1.5.5 — Operadores aritméticos: +, -, *, /, %, ++, --

Los 6 operadores aritméticos básicos

La división: entera vs decimal

Una de las confusiones más comunes. En C++ y Java:

int a = 7, b = 3;

int divisionEntera = a / b; // Resultado: 2 (se trunca la parte decimal)

double divisionDecimal = (double)a / b; // Resultado: 2.33333

int a = 7, b = 3;

int divisionEntera = a / b; // Resultado: 2

double divisionDecimal = (double)a / b; // Resultado: 2.33333

En Python, el operador / siempre da decimal:

a = 7

b = 3

resultado = a / b # 2.33333... (decimal)

resultado_entero = a // b # 2 (entero, con //)

El módulo (%): el operador mágico

El operador módulo (%) devuelve el residuo de una división. Es increíblemente útil:

Para saber si un número es par:

if (n % 2 == 0) { /* par */ }

Para saber si un número es divisible por otro:

if (n % 5 == 0) { /* divisible por 5 */ }

Para extraer dígitos:

int ultimoDigito = n % 10; // último dígito

int restoDelNumero = n / 10; // número sin el último dígito

Para hacer un ciclo (rotación):

int rotar = i % 4; // 0, 1, 2, 3, 0, 1, 2, 3, ...

Incremento (++) y decremento (--)

Ejemplo:

int x = 5;

int a = x++; // a = 5, x = 6 (toma el valor ANTES de incrementar)

int b = ++x; // b = 7, x = 7 (incrementa PRIMERO, luego asigna)

En Python no existe `++` ni `--`. Se usa `x += 1` y `x -= 1`.

Operadores de asignación compuestos

int x = 10;

x += 5; // x ahora es 15

x -= 3; // x ahora es 12

x *= 2; // x ahora es 24

1.5.6 — Operadores relacionales: ==, !=, <, >, <=, >=

Los 6 operadores de comparación

Sirven para comparar dos valores y devuelven un booleano (verdadero o falso).

Uso típico: en una condición

int edad = 18;

if (edad >= 18) {
cout << "Eres mayor de edad" << endl;

}

if (edad == 18) {
cout << "Tienes exactamente 18" << endl;

}

if (edad != 0) {
cout << "La edad no es cero" << endl;

}

El error clásico: = vs ==

Este es el error más común de los programadores junior en C++ y Java:

int x = 5;

if (x = 10) {  // ❌ ASIGNACIÓN (siempre verdadero en algunos casos, siempre falso en otros)

// ...

}

if (x == 10) { // ✅ COMPARACIÓN

// ...

}

• x = 10 asigna 10 a x (y el resultado de la asignación es 10, que en condicional se evalúa como verdadero en algunos contextos, falso en otros).
• x == 10 compara x con 10 (devuelve true o false).

Regla de oro: en una condición, usa SIEMPRE `==` para comparar. Si el compilador te avisa de un warning, lee el mensaje: probablemente te dice que confundiste `=` con `==`.

Comparación de strings: caso especial

En C++ y Python, == compara el contenido del string. En Java, hay que usar .equals():

// C++

std::string a = "Hola";

std::string b = "Hola";

if (a == b) { /* true */ }  // ✅ compara contenido

// Java

String a = "Hola";

String b = "Hola";

if (a == b) { /* NO compara contenido, compara referencia */ }  // ❌
if (a.equals(b)) { /* sí compara contenido */ }  // ✅

# Python

a = "Hola"

b = "Hola"

if a == b: # ✅ compara contenido

print("Iguales")

1.5.7 — Operadores lógicos: &&, ||, !

Los 3 operadores lógicos

Sirven para combinar condiciones (booleanos) y obtener un nuevo booleano.

Tablas de verdad

AND (`&&`): solo es verdadero si AMBAS condiciones son verdaderas.

OR (`||`): es verdadero si AL MENOS UNA condición es verdadera.

NOT (`!`): invierte el valor.

En los 3 lenguajes

Ejemplo: validar que un número está en un rango

// C++/Java: ¿está edad entre 18 y 65?

if (edad >= 18 && edad <= 65) {
cout << "Edad laboral" << endl;

}

# Python

if 18 <= edad <= 65:

print("Edad laboral")

Ejemplo: validar contraseña

// C++/Java: ¿la contraseña es al menos 8 caracteres Y tiene al menos un dígito?

if (contraseña.length() >= 8 && tieneDigito(contraseña)) {
cout << "Contraseña válida" << endl;

}

Cortocircuito (importante)

Los operadores && y || en C++/Java/Python usan evaluación de cortocircuito:

• En A && B: si A es falso, B no se evalúa.
• En A || B: si A es verdadero, B no se evalúa.

Esto es importante por dos razones:

1. Rendimiento: evita trabajo innecesario.
2. Seguridad: evita errores cuando la segunda condición depende de la primera.

if (ptr != nullptr && ptr->valor > 0) {  // Si ptr es null, no se evalúa ptr->valor

// ...

}

1.5.8 — Precedencia y asociatividad de operadores

Por qué importa

Una expresión como 2 + 3 * 4 puede interpretarse de dos formas:

• (2 + 3) * 4 = 20 (suma primero, luego multiplica)
• 2 + (3 * 4) = 14 (multiplica primero, luego suma)

La respuesta es 14 porque la multiplicación tiene mayor precedencia que la suma. Si no conoces la precedencia, escribes código que parece hacer una cosa y hace otra.

Tabla de precedencia (de mayor a menor)

Ejemplo: cómo se evalúa 2 + 3 * 4 > 10 && !false

Paso a paso:

1. 3 * 4 (precedencia 3) → 12
2. 2 + 12 (precedencia 4) → 14
3. 14 > 10 (precedencia 5) → true
4. !false (precedencia 2) → true
5. true && true (precedencia 7) → true

Resultado: true.

La regla de oro: USA PARÉNTESIS

Aunque sepas la precedencia, usa paréntesis siempre que tengas la duda. El código se lee más fácil y reduces errores:

// Sin paréntesis (legal pero confuso)

if (a + b > c * d && e || f) { /* ¿qué hace esto? */ }

// Con paréntesis (claro)

if ((a + b) > (c * d) && (e || f)) { /* ahora se entiende */ }

1.5.9 — Conversión de tipos (casting)

Qué es

El casting (o conversión de tipo) es convertir un valor de un tipo a otro. Hay dos tipos:

1. Conversión implícita: el compilador la hace automáticamente.
2. Conversión explícita: el programador la pide con sintaxis especial.

Conversión implícita (automática)

Ocurre cuando mezclas tipos en una expresión. El compilador "promueve" el tipo más pequeño al más grande:

int a = 5;

double b = a; // a (int) se convierte automáticamente a 5.0 (double)

Regla: int se convierte a long, float a double, etc. Sin pérdida de información.

Conversión explícita (forzada)

Cuando la conversión puede perder información (por ejemplo, double a int), el programador tiene que pedirla explícitamente.

En C++:

double pi = 3.14159;

int piEntera = (int)pi; // 3 (se trunca la parte decimal)

// O con la sintaxis moderna:

int piEntera2 = int(pi); // también 3

En Java:

double pi = 3.14159;

int piEntera = (int) pi; // 3

En Python:

pi = 3.14159

pi_entera = int(pi) # 3

Tabla de conversiones comunes

El problema: división de dos enteros

int a = 7, b = 3;

double resultado = a / b; // resultado = 2.0 (¡incorrecto!)

// Solución: hacer cast a double

double resultado2 = (double)a / b; // resultado2 = 2.33333

⚠️ Errores típicos — ❌ Errores típicos del razonamiento

Error 1: "Si declaro una variable, ya tengo que darle un valor"

Idea equivocada: "Primero declaro la variable y después le asigno el valor, en otra línea."

Realidad: en C++ y Java, una variable declarada pero no inicializada contiene un valor basura (lo que haya en esa posición de memoria). Si la usas antes de asignarle un valor, el comportamiento es indefinido (puede dar cualquier resultado, o crashear).

Cómo evitarlo: inicializa SIEMPRE la variable al declararla. int edad = 0; mejor que int edad;.

Error 2: "El módulo es lo mismo que el porcentaje"

Idea equivocada: "5 % 2 = 2.5% (el 2.5 por ciento de 2)."

Realidad: el módulo (%) es el residuo de la división entera. 5 % 2 = 1 (porque 5 = 2×2 + 1). No tiene nada que ver con el porcentaje.

Cómo evitarlo: piensa en % como "¿cuánto sobra después de dividir?". 7 % 3 = 1 porque 7 = 3×2 + 1, sobra 1.

Error 3: "Si dos variables valen lo mismo, sus referencias son iguales"

Idea equivocada (en Java): "Si a == b y b == 5, entonces a == 5."

Realidad: en Java, == con objetos (incluyendo Strings) compara referencias (si apuntan al mismo lugar en memoria), no contenido. Para comparar contenido, usa .equals().

Cómo evitarlo: usa .equals() para comparar strings en Java. En C++ y Python, == compara contenido de strings.

Error 4: "Los enteros y los decimales son intercambiables"

Idea equivocada: "Si tengo int x = 5, puedo hacer x / 2.0 y me da 2.5 sin problema."

Realidad: sí, pero en int x = 5; double y = x / 2; el resultado es 2.0, NO 2.5. La división 5 / 2 se hace primero (entera) y da 2; luego 2 se convierte a double.

Cómo evitarlo: cuando quieras división decimal, asegúrate de que al menos uno de los operandos sea decimal: (double)x / 2 o 5 / 2.0.

Error 5: "Los nombres largos son mejores siempre"

Idea equivocada: "Mientras más largo el nombre de la variable, más claro."

Realidad: los nombres demasiado largos también son un problema. elContadorDeIntentosRealizadosPorElUsuario es casi ilegible. La clave es el balance: descriptivo pero conciso.

Cómo evitarlo: regla de longitud: 1-2 palabras para variables simples, 3-4 para complejas. Ej: edad (1), calificacionPromedio (2), numeroIntentos (2).

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

Regla de los 3 minutos (obligatoria): 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.

Lo que la IA NO debe hacer

• ❌ No debe escribir tus ejercicios de LAB.
• ❌ No debe inventar la respuesta del Quest.
• ❌ No debe reescribir tu código completo.

Lo que SÍ debe hacer

• ✅ Explicarte un mensaje de error del compilador.
• ✅ Ayudarte a encontrar el error lógico en tu código (sin dártelo, guiándote).
• ✅ Mostrarte la diferencia entre dos versiones de tu código.

Prompts sugeridos

Prompt 1 — Entender un mensaje de error:

"El compilador me da este error al compilar mi código en C++: '[pega el mensaje del error]'. Explícame en español qué significa y qué tipo de error cometí. NO me corrijas el código. Solo dime qué hice mal. Máximo 150 palabras."

Prompt 2 — Encontrar el error lógico:

"Tengo este código en [lenguaje]. NO me lo corrijas. Solo dime: (1) ¿qué hace línea por línea? (2) ¿el resultado que produce coincide con lo que debería producir? (3) ¿dónde está el error lógico? Sé concreto, máximo 200 palabras."

Prompt 3 — Comparar dos versiones:

"Te voy a pegar dos versiones del mismo programa en C++. Una funciona y la otra no. NO me digas cuál es cuál. Solo dime: ¿qué hace cada una? ¿Qué pasa si las ejecuto con los mismos datos? Máximo 150 palabras."

Prompt 4 — Decidir el tipo de dato:

"Necesito guardar [describe el dato] en una variable. ¿Qué tipo de dato me recomiendas en C++: int, float, double, char o bool? ¿Por qué? ¿Cuánta memoria ocupa? Máximo 100 palabras."

🧪 Laboratorio — 🧪 LAB 1.5 — 8 ejercicios de codificación

Tiempo total: 2 h 30 min | Entregable: 8 programas funcionando en al menos 1 lenguaje (idealmente los 3).

Regla de oro: antes de codificar, escribe el pseudocódigo en tu cuaderno y traza con datos. Recién entonces abre el IDE.

Ejercicio 1 — Variables y tipos básicos (básico, 15 min)

Enunciado. Crea un programa que declare una variable de cada tipo primitivo (int, float, double, char, bool, string), les asigne valores, y los imprima en pantalla con un mensaje descriptivo.

Criterio de éxito: los 6 valores se imprimen correctamente.

Rúbrica (10 pts): 1 pt por cada tipo bien declarado + 4 pts por la salida formateada.

Ejercicio 2 — Calculadora de IMC (básico, 20 min)

Enunciado. Crea un programa que pida al usuario su peso (kg) y estatura (m), calcule el IMC (peso / estatura²) y muestre el resultado con un mensaje.

Criterio de éxito: calcula correctamente con datos de prueba (ej: 70 kg, 1.75 m → IMC = 22.86).

Rúbrica (10 pts): fórmula correcta (3 pts) + entrada/salida (3 pts) + formato del resultado (2 pts) + prueba con 2 datos (2 pts).

Ejercicio 3 — Constantes y áreas (básico, 15 min)

Enunciado. Crea un programa que calcule el área de un círculo pidiendo el radio al usuario. Usa const double PI = 3.14159;. Luego, generaliza el programa para que pregunte al usuario qué figura quiere calcular (1 = círculo, 2 = cuadrado, 3 = triángulo) y calcule el área correspondiente.

Criterio de éxito: maneja las 3 figuras y usa constante para PI.

Rúbrica (10 pts): uso de constante (2 pts) + 3 figuras correctas (6 pts) + menú funcional (2 pts).

Ejercicio 4 — Par, impar, positivo, negativo (intermedio, 20 min)

Enunciado. Crea un programa que pida un número entero al usuario y diga simultáneamente: si es par o impar, si es positivo o negativo, y si es múltiplo de 5.

Criterio de éxito: clasifica correctamente con 5 datos de prueba: 7, -8, 0, 15, 100.

Rúbrica (10 pts): 3 pts por cada clasificación correcta + 1 pt por la salida clara.

Ejercicio 5 — Operaciones con variables (intermedio, 20 min)

Enunciado. Crea un programa que pida dos números al usuario e imprima: su suma, resta, multiplicación, división (con decimales), división entera, módulo, y el promedio. Muestra los resultados formateados.

Criterio de éxito: los 7 resultados son correctos con datos de prueba (ej: 7 y 3 → 10, 4, 21, 2.33, 2, 1, 5).

Rúbrica (10 pts): 1 pt por cada operación + 3 pts por formato y claridad.

Ejercicio 6 — Conversor de temperatura (intermedio, 25 min)

Enunciado. Crea un programa que pida una temperatura en Celsius y la convierta a Fahrenheit y Kelvin usando las fórmulas:

• F = (C × 9/5) + 32
• K = C + 273.15

Luego, generaliza para que el usuario elija la dirección de conversión (1 = C→F, 2 = F→C, 3 = C→K, 4 = K→C).

Criterio de éxito: las 4 direcciones convierten correctamente. Verifica con 0°C = 32°F = 273.15 K.

Rúbrica (10 pts): 4 direcciones correctas (8 pts) + menú (1 pt) + formato (1 pt).

Ejercicio 7 — Cálculo de promedio y desviación estándar (avanzado, 35 min)

Enunciado. Crea un programa que pida 5 calificaciones al usuario y calcule: el promedio, la calificación más alta, la más baja, y la desviación estándar (sin usar librerías matemáticas, haz la fórmula a mano).

Criterio de éxito: los 4 cálculos son correctos con datos de prueba.

Rúbrica (10 pts): promedio (2 pts) + máximo y mínimo (3 pts) + desviación (3 pts) + formato (2 pts).

Ejercicio 8 — El mismo programa en los 3 lenguajes (avanzado, 30 min)

Enunciado. Elige UNO de los 7 ejercicios anteriores y reescríbelo en C++, Java y Python. El mismo programa, los 3 lenguajes. Compara las diferencias.

Criterio de éxito: los 3 programas producen el mismo resultado con los mismos datos.

Rúbrica (10 pts): 3 pts por cada versión correcta + 1 pt por una tabla comparativa de las diferencias.

Ejercicio bonus — Validador de CURP (avanzado, opcional, 30 min)

Enunciado. Crea un programa que pida una CURP al usuario y valide su formato (18 caracteres: 4 letras + 6 dígitos + 6 letras + 1 carácter). Solo valida el formato, no la información.

Rúbrica bonus (5 pts): 1 pt por cada parte de la CURP validada + 2 pts por mensajes de error claros.

🎯 Cierre del tema

Lo que aprendiste hoy:

• Diferencia entre variable y constante, y cuándo usar cada una.
• Reglas de nomenclatura de identificadores.
• Los 5 tipos primitivos fundamentales (entero, flotante, carácter, booleano, cadena).
• Los 3 tipos de operadores (aritméticos, relacionales, lógicos) y sus reglas de uso.
• Precedencia de operadores y el poder de los paréntesis.
• Conversión de tipos (casting) implícita y explícita.
• El mismo programa escrito en C++, Java y Python.

Lo que sigue: en el Tema 1.6 — Entorno de Desarrollo (IDE) + IA: Instalación y Configuración (6h), vas a instalar VS Code, la extensión C/C++, y vas a configurar GitHub Copilot y Codeium. Es la antesala para escribir código real con asistencia de IA. En el Tema 1.7 — Estructura de un Programa: Hola Mundo y Entrada/Salida (7h), finalmente abres el IDE y escribes tu primer programa de verdad en C++/Java/Python.

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

• [ ] 8 programas del LAB 1.5 funcionando (al menos 1 versión).
• [ ] Tabla comparativa de tipos C++/Java/Python.
• [ ] Glosario con: variable, constante, identificador, tipo primitivo, casting, precedencia, cortocircuito.

XP obtenida al completar este tema: 100 base + 30 por LAB (8 ejercicios) + 20 por Quest = 150 XP. Insignia desbloqueada al cerrar el capítulo: Data Wrangler (parcial).

*"Una variable bien nombrada es documentation. Una variable mal nombrada es deuda técnica."* — De la introducción de este manual.

Fin del Tema 1.5

📝 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. ¿Qué tipo de C++ almacena números enteros?
   • float
   • int
   • double
   • char
2. ¿Cuál es la diferencia entre int y long en C++?
   • Son iguales
   • long es típicamente más grande (8 bytes vs 4)
   • int es para texto
   • long no existe
3. ¿Qué tipo usarías para almacenar la temperatura corporal con decimales?
   • int
   • float o double
   • char
   • bool
4. ¿Qué hace el operador % en C++?
   • Porcentaje
   • Módulo (residuo de la división)
   • Comentario
   • Mayor que
5. ¿Cuál es el valor de 7 / 2 en C++ (con int)?
   • 3.5
   • 3
   • 4
   • 0
6. ¿Qué tipo de variable almacena true/false?
   • int
   • bool
   • char
   • double
7. ¿Cuál es el resultado de 10 % 3?
   • 3
   • 1
   • 0
   • 7
8. Una constante simbólica en C++ se declara con:
   • var
   • const o #define
   • let
   • static
9. ¿Qué operador compara igualdad en C++?
   • =
   • ==
   • ===
   • !=
10. ¿Qué operador incrementa una variable en 1?
    • +
    • ++
    • +=
    • --

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 cuándo usarías int, long, float y double en C++. Da un ejemplo concreto de cada uno.
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
2. ¿Qué es el overflow? Da un ejemplo de cómo evitarlo.
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
3. ¿Cuál es la diferencia entre char y string en C++? ¿Cuándo usar cada uno?
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…