2.06 · Repetitivas: `for` (con contador)

🎯 Objetivo de aprendizaje

Al terminar este tema vas a poder:

1. Explicar por qué el for es el bucle más usado en programación.
2. Escribir bucles for con inicialización, condición y actualización en una sola línea.
3. Recorrer rangos de números (1 a 10, 0 a N-1, 10 a 1).
4. Usar el for con arreglos (introducción al concepto).
5. Aplicar los 3 patrones (contador, acumulador, búsqueda) con for.
6. Decidir cuándo usar for vs while vs do-while.
7. Anidar bucles for para resolver problemas bidimensionales (tablas, matrices).

El `for` es el bucle que vas a usar el 80% del tiempo. Domínalo y tu vida como programador va a ser mucho más fácil.

🧠 Teoría y conceptos — 2.6.1 — El for: el bucle "para i desde 1 hasta N"

El problema que resuelve

Con while, escribir un bucle que cuente del 1 al 5 requiere 3 líneas separadas (inicialización, condición, actualización). Si te equivocas en una sola, el bucle no funciona.

Con for, las 3 partes van en una sola línea, en el orden lógico: primero inicialización, luego condición, luego actualización.

Sintaxis

for (inicialización; condición; actualización) {

// cuerpo del bucle

}

Equivalencia con `while`:

// Con for

for (int i = 1; i <= 5; i++) {
cout << i << endl;

}

// Equivalente con while

int i = 1; // 1. Inicialización

while (i <= 5) {      // 2. Condición
cout << i << endl;

i++; // 3. Actualización

}

La diferencia: con for, las 3 partes están VISIBLES en una sola línea, lo que reduce errores de "olvidé actualizar la variable" o "puse la condición al revés".

El ejemplo clásico: contar del 1 al 5

#include <iostream>
using namespace std;
int main() {
for (int i = 1; i <= 5; i++) {
cout << i << endl;

}

return 0;

}

Traza:

Diagrama de flujo clásico del for

┌─────────────┐

│ INICIO │ ⬭

└──────┬──────┘

│

▼

╱─────────────╲

║ INICIALIZAR ║ ▭ (parte 1: int i = 1)

║ i = 1 ║

╲ ╱

╲─────────────╱

│

▼

◆─────────────◆ ◇ (parte 2: condición)

╱ ╲

i <= 5? No ─────►

──────── │

│ │ │

Sí │ │ No │

│ │ │

▼ │ ▼

╱───────────────╲ ┌─────────────┐

║ CUERPO: ║ │ [después │

║ imprimir i ║ │ del bucle] │

╚═══════════════════╝ └──────┬──────┘

│ │

▼ │

╱─────────────╲ │

║ ACTUALIZAR ║ ▭ (parte 3: i++)

║ i = i + 1 ║ │

╲ ╱ │

╲─────────────╱ │

│ │

└──────────┬──────────┘

│

└───► (vuelve al rombo de condición)

Lo que muestra el diagrama: la inicialización y la actualización son bloques de proceso (rectángulos), mientras que la condición es un rombo. La actualización vuelve al rombo (no al inicio), formando el ciclo característico del `for`. Es esencialmente el mismo flujo que `while`, solo que las 3 partes están juntas.

2.6.2 — Las 3 partes del for en una línea

Anatomía detallada

for (int i = 1; i <= 10; i++) {

// cuerpo

}

Las 3 partes son OBLIGATORIAS pero pueden ser VACÍAS

// ❌ MAL: faltan los ;

for (int i = 1 i <= 10 i++) {  // Error de sintaxis

// ...

}

// ✅ BIEN: aunque las partes estén vacías, los ; van

for (;;) {

// Bucle infinito intencional

// (con break dentro para salir)

}

La variable del for solo existe dentro del for

for (int i = 0; i < 10; i++) {
cout << i;  // i existe aquí

}

// cout << i;  // ❌ ERROR: i no existe fuera del for

Esto se llama "alcance" (scope) y lo veremos en detalle en el Tema 2.10.

2.6.3 — Recorriendo rangos: ascendente, descendente, con paso

Ascendente (1 a N)

for (int i = 1; i <= 10; i++) {
cout << i << " ";

}

// Salida: 1 2 3 4 5 6 7 8 9 10

Descendente (N a 1)

for (int i = 10; i >= 1; i--) {
cout << i << " ";

}

// Salida: 10 9 8 7 6 5 4 3 2 1

Con paso (de 2 en 2)

for (int i = 0; i <= 20; i += 2) {
cout << i << " ";

}

// Salida: 0 2 4 6 8 10 12 14 16 18 20

Con paso negativo (de -3 en -3)

for (int i = 100; i >= 0; i -= 25) {
cout << i << " ";

}

// Salida: 100 75 50 25 0

El "off-by-one" error (error de uno por uno)

El error más común con `for`: confundir < con <=, lo que produce un resultado con un elemento de menos o de más.

// ❌ Cuenta 0, 1, 2, 3, 4 (5 elementos, no 5)

for (int i = 0; i < 5; i++) { ... }

// ✅ Cuenta 1, 2, 3, 4, 5 (5 elementos)

for (int i = 1; i <= 5; i++) { ... }

// ❌ Cuenta 1, 2, 3, 4 (4 elementos, no 5)

for (int i = 1; i < 5; i++) { ... }

Regla: traza SIEMPRE tu for con el valor inicial, el primer valor que imprime, y el último. Verifica que sean los esperados.

2.6.4 — for con patrones: contador, acumulador, búsqueda

Patrón 1: Contador con for

int contador = 0;

for (int i = 1; i <= 100; i++) {
if (/* alguna condición */) {

contador++;

}

}

cout << "Coincidencias: " << contador << endl;

Patrón 2: Acumulador con for

double suma = 0;

for (int i = 1; i <= 10; i++) {

suma += i; // suma = 0 + 1 + 2 + ... + 10 = 55

}

cout << "Suma: " << suma << endl;  // 55

Patrón 3: Búsqueda con for

int numeros[] = {10, 25, 7, 40, 15};

int objetivo = 7;

int posicion = -1;

for (int i = 0; i < 5; i++) {
if (numeros[i] == objetivo) {

posicion = i;

break; // Terminar el bucle al encontrar

}

}

if (posicion != -1) {
cout << "Encontrado en posición " << posicion << endl;
} else {
cout << "No encontrado" << endl;

}

Nota: los arreglos (`numeros[]`) se ven en detalle en el Capítulo 3. Aquí solo se mencionan para que veas la aplicación del `for`.

El break y el continue dentro del for

`break`: sale del bucle inmediatamente.

for (int i = 1; i <= 100; i++) {
if (i == 50) break;  // Sale cuando i llega a 50
cout << i << " ";

}

// Imprime 1, 2, ..., 49

`continue`: salta a la siguiente iteración.

for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) continue;  // Salta los pares
cout << i << " ";

}

// Imprime 1, 3, 5, 7, 9

2.6.5 — for anidados: tablas y matrices

El concepto

Un `for` anidado es un for dentro de otro for. Se usa cuando necesitas recorrer estructuras bidimensionales (filas y columnas).

for (int i = 1; i <= 3; i++) {       // Bucle externo (filas)
for (int j = 1; j <= 4; j++) {   // Bucle interno (columnas)
cout << "(" << i << "," << j << ") ";

}

cout << endl;

}

Salida:

(1,1) (1,2) (1,3) (1,4)

(2,1) (2,2) (2,3) (2,4)

(3,1) (3,2) (3,3) (3,4)

Traza: el bucle externo i va de 1 a 3. POR CADA valor de i, el bucle interno j va de 1 a 4 completamente. Es decir, se ejecuta 3 × 4 = 12 veces el cuerpo interno.

Ejemplo: tabla de multiplicar

for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 10; j++) {
cout << i << " x " << j << " = " << (i * j) << "\t";

}

cout << endl;

}

Salida (extracto):

1 x 1 = 1 1 x 2 = 2 1 x 3 = 3 ... 1 x 10 = 10

2 x 1 = 2 2 x 2 = 4 2 x 3 = 6 ... 2 x 10 = 20

3 x 1 = 3 3 x 2 = 6 3 x 3 = 9 ... 3 x 10 = 30

...

Diagrama de flujo del for anidado

┌─────────────┐

│ INICIO │ ⬭

└──────┬──────┘

│

▼

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

║ i = 1 ║ ▭ (externo: inicio)

╚══════╤══════╝

│

▼

◆─────────────◆ ◇ (externo: condición)

╱ ╲

i <= 5? No ──►

│ │ │

Sí │ │ No │

▼ │ ▼

╔══════════╗ [fuera]

║ j = 1 ║ ▭ (interno: inicio)

╚════╤═════╝

│

▼

◆─────────────◆ ◇ (interno: condición)

╱ ╲

j <= 10? No

│ │ │

Sí │ │ No │

▼ │ ▼

[cuerpo] │ [vuelve al externo]

│ │

└──┐ │

│ │

▼ │

╔═════════╗

║ j = j+1 ║ ▭ (interno: actualización)

╚════╤════╝

│

└────► (vuelve al rombo interno)

2.6.6 — for vs while vs do-while: cuándo usar cada uno

La regla de decisión

¿Conoces el número EXACTO de iteraciones?

├── SÍ → for

└── NO

├── ¿El cuerpo DEBE ejecutarse al menos una vez?

│ ├── SÍ → do-while

│ └── NO → while

Tabla comparativa

🤖 IA como copiloto — 🤖 AI Mission 2.6

Prompt 1: "Te voy a pegar un for en C++. NO me lo conviertas a while. Solo dime: (1) cuántas veces se ejecuta el cuerpo, (2) qué valores toma la variable de control, (3) si hay un error de 'off-by-one'. Máximo 100 palabras."

Prompt 2: "Necesito generar los primeros 10 múltiplos de 7 (7, 14, 21, ..., 70) usando un for en C++. Dame el código y explícame por qué funciona. No me corrijas nada, solo escribe el código. Máximo 100 palabras."

Prompt 3: "Te voy a pegar un patrón de anidación de for en C++. NO me corrijas. Solo dime: (1) cuántas veces se ejecuta el cuerpo interno, (2) si es eficiente o se puede simplificar, (3) qué patrón conocido es. Máximo 100 palabras."

🧪 Laboratorio — 🧪 LAB 2.6 — 6 ejercicios con for

🛠️ Herramienta recomendada para los diagramas de flujo de este LAB: Para los ejercicios que pidan un diagrama de flujo, usa [draw.io (diagrams.net)](https://app.diagrams.net/) — herramienta gratis, sin registro, que funciona en el navegador. Tiene plantillas con la simbología ANSI/ISO lista (en `General → Flowchart`). Exporta tus diagramas como PNG e insértalos en tu cuaderno digital o entrégalos junto con el código. Otras opciones libres: - [Mermaid](https://mermaid.live/) — diagramas desde código Markdown. Ideal para Git. - [Excalidraw](https://excalidraw.com/) — estilo "dibujado a mano", muy intuitivo. - Dibujar a mano en tu cuaderno — siempre válido, especialmente para trazar el razonamiento.

Ejercicio 1 — Contar del 1 al 100 (básico, 10 min)

Enunciado. Crea 3 versiones de un programa que cuente del 1 al 100 e imprima cada número:

• Con for.
• Con while.
• Con do-while.

Criterio de éxito: las 3 versiones imprimen los mismos números.

Rúbrica (10 pts): 3 pts por versión + 1 pt por el mismo output.

Ejercicio 2 — Suma y promedio de 10 números (básico, 15 min)

Enunciado. Crea un programa que pida 10 números al usuario usando un for, y calcule la suma y el promedio.

Criterio de éxito: con números 1-10, suma=55, promedio=5.5.

Rúbrica (10 pts): bucle correcto (4 pts) + suma (3 pts) + promedio (3 pts).

Ejercicio 3 — Tabla de multiplicar (básico, 15 min)

Enunciado. Pide un número N al usuario y muestra su tabla de multiplicar del 1 al 10 con formato de tabla. Usa for.

Criterio de éxito: con N=7, muestra "7 x 1 = 7" hasta "7 x 10 = 70".

Rúbrica (10 pts): bucle (3 pts) + formato (4 pts) + datos de prueba (3 pts).

Ejercicio 4 — Números pares e impares (intermedio, 20 min)

Enunciado. Crea un programa que pida N al usuario y cuente cuántos números del 1 al N son pares y cuántos impares. Usa for y un solo cout por cada caso.

Criterio de éxito: con N=10, debe dar 5 pares y 5 impares.

Rúbrica (10 pts): bucle (3 pts) + contador pares (3 pts) + contador impares (3 pts) + verificación (1 pt).

Ejercicio 5 — Patrón de asteriscos (intermedio, 25 min)

Enunciado. Crea un programa que pida N y muestre un triángulo de asteriscos:

• N=3:

*

**

***

• N=5:

*

**

***

****

*****

Usa for anidados.

Rúbrica (10 pts): bucle externo (3 pts) + bucle interno (3 pts) + formato (4 pts).

Ejercicio 6 — Factorial y potencia (avanzado, 30 min)

Enunciado. Crea un programa que pida N y M al usuario, y calcule:

• N! (factorial de N).
• N^M (N elevado a M).

Usa for para ambos. Maneja el caso N=0 (0! = 1) y M=0 (N^0 = 1).

Criterio de éxito: con N=5, 5!=120. Con N=2, M=10, 2^10=1024.

Rúbrica (10 pts): factorial (4 pts) + potencia (4 pts) + casos borde (2 pts).

Ejercicio bonus — Pirámide invertida (opcional, 30 min)

Enunciado. Crea un programa que pida N y muestre una pirámide invertida:

• N=4:

****

***

**

*

Usa for anidados.

Rúbrica bonus (5 pts): bucle correcto + formato.

🎯 Cierre del tema

Lo que aprendiste hoy:

• Por qué el for es el bucle más usado.
• Las 3 partes en una sola línea.
• Recorrer rangos: ascendente, descendente, con paso.
• break y continue.
• for anidados para tablas y matrices.
• Cuándo usar for vs while vs do-while.
• Comparación con el range() de Python.

Lo que sigue: en el Tema 2.7 — Patrones: Contadores, Acumuladores, Centinelas (8h), vas a profundizar en los patrones algorítmicos que se construyen sobre while, do-while y for. Estos patrones (suma de N, promedio, mayor, menor, búsqueda, etc.) son la base del 80% de los problemas algorítmicos en entrevistas y exámenes.

XP obtenida al completar este tema: 100 base + 30 por LAB + 20 por Quest = 150 XP.

*"Un programa sin `for` es como un carpintero sin serrucho: puede hacer cosas, pero se va a tardar el triple."* — De la introducción de este manual.

Fin del Tema 2.6

📝 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. Sintaxis de for en C++:
   • for i in range(5)
   • for (init; cond; step) { }
   • for (i=0; i<5)
   • loop { }
2. En for(int i=0; i<10; i++), ¿cuántas iteraciones?
   • 9
   • 10
   • 11
   • infinito
3. ¿Qué hace continue en un for?
   • Termina el bucle
   • Salta a la siguiente iteración (incrementa y evalúa)
   • Reinicia
   • Duerme
4. ¿Para qué sirve for en C++?
   • Definir funciones
   • Repetir un bloque con contador
   • Crear archivos
   • Compilar
5. for anidados se usan para:
   • Definir variables
   • Recorrer matrices 2D o patrones
   • Compilar
   • Crear clases
6. ¿Qué hace break en un for?
   • Reinicia
   • Sale del bucle
   • Duerme
   • Suma
7. Si el for tiene for(int i=0; i<5; ) sin incremento, ¿qué pasa?
   • 5 iteraciones
   • Bucle infinito
   • 0 iteraciones
   • 1 iteración
8. ¿Cuántos ; tiene la cabecera de un for en C++?
   • 1
   • 2
   • 3
   • 4
9. for(int i=10; i>0; i--), ¿cuántas iteraciones?
   • 0
   • 10
   • 11
   • infinito
10. ¿Qué tipo de variable se usa commonly en un for?
    • float
    • int (contador)
    • char
    • bool

Sección B · Preguntas abiertas

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

1. Convierte este while a for: int i=0; while(i<10) { ...; i++; }
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
2. ¿Qué hace un for-each en C++ (range-based for)? ¿Cuándo usarlo?
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
3. Diseña un for anidado que imprima una matriz 3x3 con sus posiciones.
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…