Síntesis y desafíos: primeros pasos

Resumen

Esta clase cierra la primera unidad del curso, dedicada a los primeros pasos en la programación con C++. Reconstruye la cadena de conceptos que va del problema especificado al error clasificado por su momento, pasando por el algoritmo, el código fuente, la compilación y el enlace, el ejecutable y la comunicación del programa con el exterior; separa lo que de todo ello vale en cualquier lenguaje de lo que es propio de C++; reúne el comportamiento indefinido que la unidad ha mostrado y la regla del curso que de él se sigue, compilar siempre con avisos y, mientras se desarrolla, con detectores; repite en su evaluación de salida las destrezas de la evaluación de entrada; y termina con seis desafíos que combinan la unidad entera: el vuelto con el menor número de monedas, una tabla alineada sin bucles, un programa con cinco defectos de cinco clases, un experimento sobre el búfer de salida, una fecha con formato fijo y la explicación del compilador a quien solo conoce un lenguaje interpretado.

Objetivos de aprendizaje

Recorrer sin ayuda el camino del enunciado al programa ejecutado: especificar, escribir el algoritmo, seguirlo a mano, escribirlo en C++, compilarlo con las opciones del curso, ejecutarlo y comprobar su resultado.
Explicar qué herramienta actúa en cada paso de ese camino (editor, preprocesador, compilador, enlazador, detectores) y qué recibe y entrega cada una.
Reconocer la clase de un error (de compilación, de enlace, de ejecución o de lógica) por su manifestación, y corregir varios errores en el orden en que se revelan.
Explicar con un ejemplo qué es el comportamiento indefinido y por qué el curso compila con avisos y detectores.
Separar, en lo aprendido en la unidad, lo que vale en cualquier lenguaje de lo que es propio de C++.

Lo logrado en la unidad

La unidad se propuso llevar a quien nunca ha programado desde un problema enunciado en lenguaje corriente hasta un programa que compila, se ejecuta, lee datos y escribe resultados, sabiendo qué hizo cada herramienta en el camino. Lo ha logrado apoyándose solo en lo que la introducción declaró por sabido: la aritmética escolar, la costumbre de seguir instrucciones escritas y el manejo de archivos y carpetas.

Del problema al algoritmo

La clase Del problema al algoritmo estableció que un problema se fija por su especificación, un contrato que promete la poscondición a toda entrada que cumpla la precondición y nada fuera de ella. Un algoritmo es un procedimiento finito, preciso y general, que se escribe en pasos numerados, se sigue a mano con una tabla de traza y se compone de secuencia, decisión y repetición; cada repetición se acompaña de una variante, una cantidad natural que decrece en cada vuelta y garantiza que termina.

Programas, compiladores y C++

La clase Programas, compiladores y C++ mostró que el texto de un programa de C++ no se ejecuta tal cual: el preprocesador, el compilador y el enlazador lo convierten en un ejecutable. De ello se siguió la distinción que atraviesa la unidad: lo que depende solo del texto se descubre al compilar o al enlazar, y lo que depende de los datos, solo al ejecutar. La clase comparó el modelo compilado con el interpretado y justificó que el curso use C++23 y la pida con -std=c++23.

Instalar el entorno

La clase Instalar el entorno en Windows, macOS y Linux instaló un compilador capaz de C++23 y Visual Studio Code con su extensión de C++. Su lección de método es que el editor no compila, sino que llama a un compilador que la terminal debe encontrar, y que el texto exacto de un mensaje distingue la falla de instalación de la falla de invocación.

Compilar, ejecutar y configurar

La clase Compilar, ejecutar y configurar fijó el ciclo de editar, guardar, compilar, ejecutar y leer, y la orden del curso. Distinguió el error, que impide el ejecutable, del aviso, que lo permite pero señala código sospechoso; activó los detectores, que vigilan la ejecución, y mostró sus límites; y explicó que archivo, compilador y consola deben coincidir en UTF-8.

Anatomía de un programa

La clase Anatomía de un programa disecó el programa mínimo: las cabeceras, que declaran cada dependencia; main, punto de entrada cuyo valor es el código de salida; el espacio de nombres std; las sentencias, los bloques y los comentarios. Enseñó a leer los mensajes desde el primero y fijó la guía de estilo del curso.

Entrada, salida y errores

La clase Entrada, salida y errores puso al programa en contacto con el exterior: std::println escribe exactamente lo pedido, con campos de formato, y std::cin lee y se detiene en el primer carácter que no sirve. Una lectura fallida pone la variable en cero y deja el flujo en error, en silencio; por eso la lectura se comprueba. La clase cerró la unidad clasificando los errores por su momento: de compilación, de enlace, de ejecución y de lógica.