2.03 · Operadores Lógicos y Tablas de Verdad

🎯 Objetivo de aprendizaje

Al terminar este tema vas a poder:

1. Memorizar y aplicar las tablas de verdad de los 3 operadores lógicos (&&, ||, !) sin dudar.
2. Combinar 2 o más condiciones usando && (AND) y || (OR) para crear filtros complejos.
3. Aplicar las propiedades lógicas: conmutativa, asociativa, distributiva, De Morgan.
4. Simplificar condiciones complejas usando las propiedades lógicas y el sentido común.
5. Usar correctamente la evaluación de cortocircuito para escribir código seguro y eficiente.
6. Identificar y corregir los 3 errores más comunes: confundir && con ||, no usar paréntesis, escribir condiciones imposibles o redundantes.
7. Construir validadores de formularios (login, contraseñas, datos de entrada) usando solo operadores lógicos.

Este tema es la base de TODAS las decisiones complejas en programación. Si no dominas los operadores lógicos, no puedes escribir ni un formulario de login decente.

🧠 Teoría y conceptos — 2.3.1 — Repaso: los 3 operadores lógicos y sus tablas de verdad

Los 3 operadores en los 3 lenguajes

La tabla de verdad del AND (&& / and)

El AND es verdadero SOLO si AMBAS condiciones son verdaderas.

Mnemotécnica: "Para que A Y B sea verdadero, las DOS tienen que ser verdaderas. Si UNA falla, todo falla."

La tabla de verdad del OR (|| / or)

El OR es verdadero si AL MENOS UNA condición es verdadera.

Espera, la analogía del OR es complicada. Mejor esta: OR es como un "o" inclusivo en español. "Voy al cine O voy al teatro" puede significar que voy a uno O al otro O a los dos. Mientras al menos uno se cumpla, es verdadero.

Mnemotécnica: "Para que A O B sea verdadero, AL MENOS UNA tiene que ser verdadera. Si TODAS fallan, falla."

La tabla de verdad del NOT (! / not)

El NOT invierte el valor.

Mnemotécnica: "NOT es como el 'no' del español. Niega lo que viene después."

Combinaciones de 3 valores (AND, OR, NOT)

Las tablas se pueden extender. Para 3 valores A, B, C:

AND de 3: verdadero solo si las TRES son verdaderas. OR de 3: verdadero si AL MENOS UNA es verdadera. NOT de AND: !(A && B) es lo mismo que (!A || !B) — Ley de De Morgan.

2.3.2 — Combinación de condiciones: de 2 a N

Combinar 2 condiciones con &&

if (edad >= 18 && tieneLicencia) {
cout << "Puedes conducir" << endl;

}

Significado: "La edad es mayor o igual a 18 Y tiene licencia". AMBAS deben ser verdaderas.

Casos que lo hacen verdadero:

• edad = 25, tieneLicencia = true → ✓
• edad = 18, tieneLicencia = true → ✓
• edad = 30, tieneLicencia = true → ✓

Casos que lo hacen falso:

• edad = 15, tieneLicencia = true → ✗ (falta edad)
• edad = 25, tieneLicencia = false → ✗ (falta licencia)
• edad = 15, tieneLicencia = false → ✗ (faltan ambas)

Combinar 2 condiciones con ||

if (esEstudiante || esAdultoMayor) {
cout << "Tienes descuento" << endl;

}

Significado: "Es estudiante O es adulto mayor". AL MENOS UNA debe ser verdadera.

Casos que lo hacen verdadero:

• esEstudiante = true, esAdultoMayor = false → ✓
• esEstudiante = false, esAdultoMayor = true → ✓
• esEstudiante = true, esAdultoMayor = true → ✓ (¡las dos!)

Casos que lo hacen falso:

• esEstudiante = false, esAdultoMayor = false → ✗ (ninguna)

Combinar 3 o más condiciones

// Puedes votar si: eres mexicano, tienes 18+, y tienes INE

if (esMexicano && edad >= 18 && tieneINE) {
cout << "Puedes votar" << endl;

}

// Aprobado si: promedio >= 7, O (asistencia >= 90% y tareas >= 80%)

if (promedio >= 7 || (asistencia >= 90 && tareas >= 80)) {
cout << "Aprobado" << endl;

}

Nota los paréntesis en el segundo ejemplo: agrupan (asistencia >= 90 && tareas >= 80) para que se evalúe como una unidad antes del OR.

Mezclar && y || con paréntesis

Regla: cuando mezcles, usa paréntesis para ser explícito, aunque el lenguaje respete la precedencia.

// ✅ BIEN: paréntesis explícitos

if ((esEstudiante || esAdultoMayor) && tieneMembresia) {

// Descuento solo si (estudiante o adulto mayor) Y tiene membresía

}

// ❌ MAL: sin paréntesis, depende de la precedencia del lenguaje

if (esEstudiante || esAdultoMayor && tieneMembresia) {

// El && tiene mayor precedencia, así que se evalúa como:

// esEstudiante || (esAdultoMayor && tieneMembresia)

// Que es DIFERENTE al primer caso

}

2.3.3 — Las propiedades lógicas: conmutativa, asociativa, distributiva, De Morgan

Por qué importan

Las propiedades lógicas te permiten simplificar condiciones y verificar que dos condiciones son equivalentes. Esto es útil cuando:

• Estás depurando y no entiendes por qué una condición compleja da un resultado.
• Estás revisando código de un compañero y quieres asegurarte de que una condición es correcta.
• Estás optimizando código y quieres quitar comparaciones redundantes.

Conmutativa

El orden de los operandos no importa en && y ||.

A && B ⇔ B && A

A || B ⇔ B || A

Ejemplo:

if (edad >= 18 && tieneLicencia)  // Equivale a:
if (tieneLicencia && edad >= 18)  // Mismo resultado

Asociativa

El agrupamiento de los operandos no importa en && y || (mientras no mezcles).

(A && B) && C ⇔ A && (B && C)

(A || B) || C ⇔ A || (B || C)

Ejemplo:

if ((esMexicano && edad >= 18) && tieneINE)  // Equivale a:
if (esMexicano && (edad >= 18 && tieneINE))  // Mismo resultado

Distributiva

&& distribuye sobre ||, y viceversa, como la multiplicación sobre la suma.

A && (B || C) ⇔ (A && B) || (A && C)

A || (B && C) ⇔ (A || B) && (A || C)

Ejemplo:

// "Cliente VIP: (es cliente Y tiene membresía) O (gastó más de $10,000)"

if (esCliente && (tieneMembresia || gasto > 10000))  // Equivale a:
if ((esCliente && tieneMembresia) || (esCliente && gasto > 10000))

Leyes de De Morgan (las más útiles)

Las leyes de De Morgan son las más importantes para depurar:

!(A && B) ⇔ !A || !B

!(A || B) ⇔ !A && !B

En español: "la negación de una conjunción es la disyunción de las negaciones".

Ejemplo práctico: "NO es estudiante Y NO es adulto mayor" es lo mismo que "NO (es estudiante O es adulto mayor)".

// Si quieres "descuento solo si NO es estudiante Y NO es adulto mayor"

if (!esEstudiante && !esAdultoMayor)  // Equivale a:
if (!(esEstudiante || esAdultoMayor))  // Más conciso

¿Por qué importa De Morgan? porque cuando niegas una condición compuesta (con !), la transformación de && a || y viceversa es donde más errores cometen los programadores.

Cómo usar las propiedades en la práctica

Caso 1: Verificar equivalencia de dos condiciones.

Tienes:

if (!esAdmin && !esEditor)

¿Es equivalente a:

if (!(esAdmin || esEditor))

Sí, por De Morgan. Confirma que la lógica es la misma.

Caso 2: Simplificar una condición.

Tienes:

if (x > 0 && !(x < 0 || x == 0))

Por De Morgan, !(x < 0 || x == 0) = x >= 0. Entonces:

if (x > 0 && x >= 0)  // Se simplifica a:
if (x > 0)  // porque si x > 0, entonces x >= 0

Caso 3: Negar una condición del enunciado.

El problema dice "no debe haber usuarios duplicados". Traduces a:

// (Usuarios duplicados = hay 2 usuarios con el mismo email)

if (!hayDuplicados) {

// Permitir

}

Aplicando De Morgan:

if (!hayDuplicados)  // Equivale a:
if (noHayDuplicados)  // Más claro

2.3.4 — Evaluación de cortocircuito: eficiencia y seguridad

Qué es (repasando del Tema 2.1)

Los operadores && y || usan evaluación de cortocircuito: si el resultado ya se conoce, no se evalúa el resto.

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

Por qué importa: eficiencia

En condiciones complejas donde la primera es rápida y la segunda es cara, el cortocircuito ahorra trabajo:

// Si lista está vacía, no se evalúa el [0]

if (!lista.empty() && lista[0] == "algo") {

// ...

}

Por qué importa: SEGURIDAD (más importante)

Cuando la segunda condición podría CRASHEAR el programa si la primera es falsa, el cortocircuito la protege:

// Si ptr es null, no se evalúa ptr->valor (crashearía)

if (ptr != nullptr && ptr->valor > 0) {

// ...

}

// Si divisor es 0, no se evalúa la división

if (divisor != 0 && numerador / divisor > 10) {

// ...

}

Diagrama de flujo clásico del cortocircuito (con &&)

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

│ INICIO │ ⬭

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

│

▼

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

╱ ptr != null ╲ ◇ (1ª decisión)

╲ ╱

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

│

▼

◆─────────────◆ ◇

╱ ╲

ptr es null? ptr NO es null

──────── ──────────

│ │ │

Sí │ │ No ▼

│ │ ◆─────────────◆ ◇

│ │ ╱ ╲

│ │ ptr->valor > 0? │

│ │ ──────── │

│ │ │ │ │

│ │Sí │ │ No │

│ │ │ │ │

▼ │ ▼ ▼ ▼

(no se evalúa │ Sí No (no entra

la 2ª cond, │ │ │ al if)

sigue el flujo │ ▼ ▼

sin entrar) │ (entra al if)

│

▼

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

│ FIN │ ⬭

└─────────────┘

Lo que muestra el diagrama: si ptr es null, el flujo NO continúa hacia la segunda decisión. La flecha "Sí" del primer rombo lleva a FIN directamente (saltándose la segunda evaluación). Esto es exactamente el cortocircuito: si la primera condición ya garantiza el resultado, no se evalúa la segunda.

Si no hubiera cortocircuito, tendrías que anidar `if`:

// Versión SIN cortocircuito (verbosa pero clara)

if (ptr != nullptr) {
if (ptr->valor > 0) {

// ...

}

}

Versión CON cortocircuito (más concisa):

if (ptr != nullptr && ptr->valor > 0) {

// ...

}

Ambas hacen lo mismo, pero la segunda es más elegante.

Cuidado con los efectos secundarios

El cortocircuito puede causar bugs si la segunda condición tiene un efecto secundario (modifica una variable, escribe en archivo, etc.):

int i = 0;

if (false && ++i < 10) {  // ++i NO se ejecuta

// ...

}

cout << i;  // Imprime 0, no 1

Lección: si necesitas que AMBAS condiciones se ejecuten siempre, no uses cortocircuito. O usa & y | (no && ni || en algunos lenguajes) para forzar la evaluación de ambos. Pero esto es raro en introductory.

2.3.5 — Simplificación de condiciones complejas

El arte de escribir condiciones claras

Una condición compleja no es "más sofisticada" que una simple. Una condición simple y clara es mejor que una compleja, aunque signifique más código.

Ejemplo de condición compleja (mala):

if ((edad >= 18 && tieneLicencia) || (edad >= 16 && tienePermisoEspecial)) {

// ...

}

Versión simplificada (mejor):

bool puedeConducir = (edad >= 18 && tieneLicencia) || (edad >= 16 && tienePermisoEspecial);

if (puedeConducir) {

// ...

}

O extraída a función (todavía mejor):

bool puedeConducir(int edad, bool tieneLicencia, bool tienePermisoEspecial) {

return (edad >= 18 && tieneLicencia) || (edad >= 16 && tienePermioEspecial);

}

// ...

if (puedeConducir(edad, tieneLicencia, tienePermiso)) {

// ...

}

5 técnicas de simplificación

1. Extraer a variable booleana:

if (esEstudiante || esAdultoMayor || esDiscapacitado) {

// ...

}

// Simplificado:

bool tieneDescuento = esEstudiante || esAdultoMayor || esDiscapacitado;

if (tieneDescuento) {

// ...

}

1. Extraer a función:

bool tieneDerechoADescuento(int edad, bool esEstudiante, bool esDiscapacitado) {

return edad < 18 || edad >= 65 || esEstudiante || esDiscapacitado;

}

1. Usar la ley del medio excluido:

// Si A es booleano, "A o no A" siempre es true

// Si A es booleano, "A y no A" siempre es false

1. Quitar comparaciones redundantes:

// ❌ Redundante

if (x > 0 && x >= 0)  // x > 0 ya implica x >= 0

// ✅ Limpio

if (x > 0)

1. Usar la condición opuesta con `if-else`:

// En vez de:

if (condicionCompleja) {

// caso raro

} else {

// caso común

}

// A veces es más claro:

if (!condicionCompleja) {

// caso común

} else {

// caso raro

}

⚠️ Errores típicos — 2.3.6 — Errores comunes: confundir && con ||, condiciones imposibles o redundantes

Error 1: Confundir && con ||

Caso clásico: la edad para beber en México.

// ❌ MAL: estás diciendo "tienes 18 O tienes 0, te doy alcohol"

// (con AND, una persona de 0 años NO puede; con OR, sí)

if (edad == 18 || edad == 21) {  // Equivocación común
cout << "Puedes beber" << endl;

}

// ✅ BIEN: solo si tiene 18 O más años

if (edad >= 18) {
cout << "Puedes beber" << endl;

}

Por qué pasa: porque en español "mayor de 18" se entiende intuitivamente, pero al traducirlo a lógica, hay que decidir entre == y >=, y entre && y ||.

Cómo evitarlo: escribe la condición en español primero. "Puedes beber si tienes 18 años o más". Traduce literal: if (edad >= 18). No metas un || extra.

Error 2: Condiciones imposibles

// ❌ MAL: nunca verdadero (x no puede ser > 5 Y <= 3 al mismo tiempo)

if (x > 5 && x <= 3) {
cout << "¡Hola!" << endl;

}

Por qué pasa: por descuido al escribir la condición. Las dos sub-condiciones no se pueden cumplir simultáneamente.

Cómo evitarlo: traza con datos de prueba. ¿Hay algún valor de x que cumpla las dos? Si no, es imposible.

Error 3: Condiciones redundantes

// ❌ MAL: x >= 0 ya implica x != -1

if (x >= 0 && x != -1) {

// ...

}

// ❌ MAL: si es VIP ya implica que es cliente

if (esVIP && esCliente) {

// ...

}

Por qué pasa: porque añadimos condiciones "por si acaso" sin pensar.

Cómo evitarlo: pregúntate: "¿la segunda condición añade información nueva?" Si no, es redundante.

Error 4: Negar la condición completa por error

// ❌ MAL: querías decir "el usuario NO está bloqueado"

if (!esBloqueado == true) {  // Doble negación confusa

// ...

}

// ✅ BIEN: simplemente di lo que quieres

if (!esBloqueado) {  // Mejor

// ...

}

// O mejor aún, usa una variable con nombre positivo

if (puedeAcceder) {  // Nombre claro

// ...

}

Por qué pasa: porque mezclar ! con == y == true es propenso a errores.

Cómo evitarlo: nombra las variables booleanas de forma positiva: puedeAcceder, tienePermisos, esValido (no noEsInvalido).

Error 5: Usar && cuando quieres || (o viceversa) por error de diseño

Caso real: sistema de login.

// ❌ MAL: "puede entrar si tiene usuario Y contraseña" — siempre

// falla porque también quieres que sea válido

if (tieneUsuario && tienePassword) {
cout << "Acceso permitido" << endl;

}

// Resultado: nadie puede entrar aunque la contraseña sea correcta

// ✅ BIEN: debe tener AMBAS

if (tieneUsuario && tienePassword && sonValidos) {
cout << "Acceso permitido" << endl;

}

Por qué pasa: porque al diseñar la condición, se nos olvidó un requisito.

Cómo evitarlo: antes de codificar, escribe los requisitos en español:

• "Para entrar: (1) tener usuario, (2) tener contraseña, (3) que ambos sean válidos".
• Traduce a: tieneUsuario && tienePassword && sonValidos.

❌ Errores típicos del razonamiento

Error 1: "Las tablas de verdad son para matemáticos, no las necesito memorizar"

Idea equivocada: "Con la práctica, ya las voy a aprender."

Realidad: las tablas de verdad se olvidan. Memorízalas AHORA. Es 5 minutos de esfuerzo para algo que vas a usar TODOS los días de tu carrera.

Cómo evitarlo: repítelas 3 veces al día durante una semana. Después, son parte de ti.

Error 2: "Mientras la condición compile, está bien"

Idea equivocada: "El compilador acepta mi && y ||, así que es correcto."

Realidad: el compilador verifica SINTAXIS, no SEMÁNTICA. && y || son sintácticamente válidos siempre; lo que importa es si los usaste correctamente para lo que querías decir.

Cómo evitarlo: traza con datos de prueba. Para cada combinación posible de las variables, verifica que el resultado sea el esperado.

Error 3: "Las leyes de De Morgan son muy avanzadas, no las voy a usar"

Idea equivocada: "De Morgan es para cursos de lógica matemática, no para programación del día a día."

Realidad: De Morgan la vas a usar CADA VEZ que niegues una condición compuesta. Si la condición tiene &&, al negarla se convierte en ||, y viceversa. Si no lo sabes, vas a escribir la condición negada mal.

Cómo evitarlo: practica De Morgan con 5 condiciones propias hasta que sea automática.

Error 4: "El cortocircuito es un detalle del compilador, no me afecta"

Idea equivocada: "El compilador optimiza, yo solo escribo la condición."

Realidad: el cortocircuito es parte de la SEMÁNTICA del lenguaje, no una optimización. Si escribes if (ptr != nullptr && ptr->valor > 0) y NO hay cortocircuito, el programa crashea. Dependes de él para escribir código seguro.

Cómo evitarlo: siempre que uses && o || con condiciones que podrían fallar, verifica que el cortocircuito te protege. Si no, usa if anidados.

Error 5: "Si la condición es muy larga, mejor la pongo en una sola línea"

Idea equivocada: "Una línea de 200 caracteres es más eficiente que varias."

Realidad: una línea de 200 caracteres es ilegible. El compilador no se queja, pero tú y tus compañeros sí. Divide en variables con nombre, o extrae a función.

Cómo evitarlo: regla de longitud: máximo 100 caracteres por línea. Si la condición pasa de eso, divídela.

🤖 IA como copiloto — 🤖 AI Mission 2.3 — Lógica con IA

Prompts sugeridos

Prompt 1 — Verificar una condición:

"Te voy a pegar una condición en C++: '[condición]'. Explica con palabras qué significa esta condición, sin usar jerga técnica. ¿Hay algún caso donde la condición es verdadera pero no debería serlo? Máximo 100 palabras."

Prompt 2 — Simplificar:

"Te voy a pegar una condición compleja en C++. NO me la corrijas. Solo dime: (1) si se puede simplificar, (2) qué propiedad lógica aplicaría (De Morgan, conmutativa, etc.), (3) cómo quedaría. Máximo 100 palabras."

Prompt 3 — Detectar error lógico:

"Mi programa debería hacer X si la condición se cumple, pero a veces hace Y en su lugar. Te pego la condición: '[condición]'. NO me la corrijas. Solo dime: (1) qué hace exactamente, (2) qué posibles inputs la harían fallar, (3) por qué. Máximo 150 palabras."

Prompt 4 — Validar un formulario:

"Necesito validar un formulario de registro con estos requisitos: (lista). Dame el código C++ que valide todos los requisitos y muestre al usuario cuáles faltan. No me corrijas nada, solo escribe el código. Máximo 200 palabras."

🧪 Laboratorio — 🧪 LAB 2.3 — 5 ejercicios de lógica aplicada

Tiempo total: 1 h | Entregable: 5 programas funcionando.

🛠️ 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 — Validador de edad (básico, 10 min)

Enunciado. Crea un programa que pida la edad y diga simultáneamente:

• "Niño" si edad < 12.
• "Adolescente" si 12 <= edad < 18.
• "Adulto" si 18 <= edad < 65.
• "Adulto mayor" si edad >= 65.
• "Edad inválida" si edad < 0.

Criterio de éxito: los 5 casos se clasifican correctamente.

Rúbrica (10 pts): 5 casos × 2 pts.

Ejercicio 2 — Validador de triángulo (básico, 15 min)

Enunciado. Crea un programa que pida 3 lados y determine:

• Si NO es triángulo válido (algún lado <= 0, o la suma de 2 lados no es mayor al tercero).
• Si es equilátero, isósceles, escaleno.
• Si es rectángulo (a² + b² = c² con c como el lado mayor).

Criterio de éxito: los 5 casos (no triángulo, equilátero, isósceles, escaleno, rectángulo) funcionan.

Rúbrica (10 pts): 5 casos × 2 pts.

Ejercicio 3 — Validador de contraseña (intermedio, 20 min)

Enunciado. Implementa el validador de contraseñas de la sección de comparación. La contraseña debe tener:

• Mínimo 8 caracteres.
• Al menos una mayúscula.
• Al menos una minúscula.
• Al menos un dígito.
• Al menos un carácter especial.

Si no cumple, muestra cuáles requisitos faltan.

Criterio de éxito: valida correctamente 4 contraseñas: "abc" (inválida por longitud y sin mayúscula), "abcdefgh" (sin dígito ni especial), "Abcdefg1" (sin especial), "Abcdefg1!" (válida).

Rúbrica (10 pts): 4 contraseñas de prueba correctas (8 pts) + mensajes específicos (2 pts).

Ejercicio 4 — Sistema de acceso multinivel (avanzado, 25 min)

Enunciado. Crea un sistema de login con 3 niveles:

• Nivel 1 (usuario): solo puede ver el perfil.
• Nivel 2 (editor): puede ver y editar.
• Nivel 3 (admin): puede ver, editar y eliminar.

Pide al usuario: nombre, contraseña, y rol. Valida:

• Si el rol no es 1, 2 o 3: "Rol inválido".
• Si la contraseña es incorrecta para ese rol: "Acceso denegado".
• Si todo es correcto, muestra el menú según el rol.

Usa una matriz de contraseñas hardcodeada (por ejemplo: usuario: "user123", editor: "edit456", admin: "admin789").

Criterio de éxito: los 4 roles (3 válidos + 1 inválido) funcionan correctamente.

Rúbrica (10 pts): 3 roles válidos (6 pts) + rol inválido (2 pts) + menús por rol (2 pts).

Ejercicio 5 — Decodificador de caracteres (avanzado, 25 min)

Enunciado. Crea un programa que pida un carácter y determine:

• Si es una vocal (a, e, i, o, u, mayúscula o minúscula).
• Si es una consonante.
• Si es un dígito (0-9).
• Si es un carácter especial (nada de lo anterior).

Pista: usa la tabla ASCII y comparaciones con códigos numéricos, o usa funciones como isalpha, isdigit, etc.

Criterio de éxito: clasifica correctamente 4 caracteres: 'a' (vocal), 'Z' (consonante), '5' (dígito), '#' (especial).

Rúbrica (10 pts): 4 caracteres × 2 pts + 2 pts por el uso correcto de funciones de clasificación.

🎯 Cierre del tema

Lo que aprendiste hoy:

• Las tablas de verdad de &&, ||, !.
• Cómo combinar 2 o más condiciones.
• Las propiedades lógicas: conmutativa, asociativa, distributiva, De Morgan.
• La evaluación de cortocircuito y por qué importa para la seguridad.
• Cómo simplificar condiciones complejas.
• Los 5 errores más comunes con condiciones.
• Un validador de contraseñas profesional en 3 lenguajes.

Lo que sigue: en el Tema 2.4 — Repetitivas: `while` (7h), vas a aprender la primera estructura repetitiva: el bucle while. Con esto, tus programas van a poder repetir acciones sin que tengas que escribir el mismo código 100 veces. Es la base de todo lo que viene: el for, el do-while, los patrones de contadores y acumuladores.

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

• [ ] 5 programas del LAB 2.3 funcionando.
• [ ] Las 3 tablas de verdad memorizadas.
• [ ] Las 4 propiedades lógicas con ejemplos propios.
• [ ] Glosario con: &&, ||, !, tabla de verdad, conmutativa, asociativa, distributiva, De Morgan, cortocircuito, condición imposible, condición redundante.

XP obtenida al completar este tema: 100 base + 20 por LAB + 20 por Quest = 140 XP. Insignia desbloqueada al cerrar el capítulo: Boolean Alchemist (parcial).

*"Un programa sin booleanos es una receta. Un programa con booleanos es un juez. La diferencia es la capacidad de decir sí o no, con matices."* — De la introducción de este manual.

Fin del Tema 2.3

📝 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é operador lógico es AND en C++?
   • AND
   • &&
   • &
   • and
2. ¿Qué operador lógico es OR en C++?
   • OR
   • ||
   • |
   • or
3. ¿Qué es una tabla de verdad?
   • Una base de datos
   • Una tabla que muestra el resultado de operadores lógicos
   • Un programa
   • Un tipo de variable
4. Para && (AND), ¿cuál es el resultado de true && false?
   • true
   • false
   • null
   • error
5. Para || (OR), ¿cuál es el resultado de false || false?
   • true
   • false
   • null
   • 1
6. ¿Qué es "evaluación de cortocircuito"?
   • Un bug
   • Si el primer operando de && es false, no evalúa el segundo
   • Truncar strings
   • Tipo de bucle
7. Si a=5, b=0, ¿qué pasa con (b!=0 && a/b>2)?
   • División por cero
   • Cortocircuito: false sin evaluar a/b
   • 2.5
   • Crash
8. Para ! (NOT), ¿cuál es el resultado de !true?
   • true
   • false
   • 1
   • null
9. ¿Qué operador tiene mayor precedencia: && o ||?
   • ||
   • &&
   • Son iguales
   • Depende del lenguaje
10. (true || false) && false = ?
    • true
    • false
    • null
    • error

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 la evaluación de cortocircuito y por qué es importante para la seguridad.
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
2. Diseña una expresión lógica para "mayor de edad Y con licencia O con permiso especial".
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
3. ¿Por qué De Morgan es importante? Escribe el equivalente de !(A && B) y !(A || B).
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…