Síntese e desafios: primeiros passos

Resumo

Esta aula encerra a primeira unidade do curso, dedicada aos primeiros passos na programação com C++. Reconstrói a cadeia de conceitos que vai do problema especificado ao erro classificado pelo seu momento, passando pelo algoritmo, pelo código-fonte, pela compilação e pela ligação, pelo executável e pela comunicação do programa com o exterior; separa o que de tudo isso vale em qualquer linguagem do que é próprio de C++; reúne o comportamento indefinido que a unidade mostrou e a regra do curso que dele decorre, compilar sempre com avisos e, durante o desenvolvimento, com detectores; repete na sua avaliação de saída as habilidades da avaliação de entrada; e termina com seis desafios que combinam a unidade inteira: o troco com o menor número de moedas, uma tabela alinhada sem laços, um programa com cinco defeitos de cinco tipos, um experimento sobre o buffer de saída, uma data com formato fixo e a explicação do compilador para quem só conhece uma linguagem interpretada.

Objetivos de aprendizagem

Percorrer sem ajuda o caminho do enunciado ao programa executado: especificar, escrever o algoritmo, rastreá-lo à mão, escrevê-lo em C++, compilá-lo com as opções do curso, executá-lo e verificar seu resultado.
Explicar que ferramenta atua em cada passo desse caminho (editor, pré-processador, compilador, ligador, detectores) e o que cada uma recebe e entrega.
Reconhecer o tipo de um erro (de compilação, de ligação, de execução ou de lógica) pela sua manifestação, e corrigir vários erros na ordem em que se revelam.
Explicar com um exemplo o que é o comportamento indefinido e por que o curso compila com avisos e detectores.
Separar, no que se aprendeu na unidade, o que vale em qualquer linguagem do que é próprio de C++.

O que a unidade alcançou

A unidade se propôs levar quem nunca programou de um problema enunciado em linguagem corrente até um programa que compila, executa, lê dados e escreve resultados, sabendo o que cada ferramenta fez no caminho. Conseguiu-o apoiando-se apenas no que a introdução declarou como sabido: a aritmética escolar, o hábito de seguir instruções escritas e o manejo de arquivos e pastas.

Do problema ao algoritmo

A aula Do problema ao algoritmo estabeleceu que um problema se fixa pela sua especificação, um contrato que promete a pós-condição a toda entrada que cumpra a pré-condição e nada fora dela. Um algoritmo é um procedimento finito, preciso e geral, que se escreve em passos numerados, se rastreia à mão com uma tabela de rastreamento e se compõe de sequência, decisão e repetição; cada repetição se acompanha de uma variante, uma quantidade natural que decresce a cada iteração e garante que ela termina.

Programas, compiladores e C++

A aula Programas, compiladores e C++ mostrou que o texto de um programa em C++ não se executa tal como está: o pré-processador, o compilador e o ligador o convertem em um executável. Disso decorreu a distinção que atravessa a unidade: o que depende só do texto se descobre ao compilar ou ao ligar, e o que depende dos dados, só ao executar. A aula comparou o modelo compilado com o interpretado e justificou que o curso use C++23 e o peça com -std=c++23.

Instalar o ambiente

A aula Instalar o ambiente em Windows, macOS e Linux instalou um compilador capaz de C++23 e o Visual Studio Code com sua extensão de C++. Sua lição de método é que o editor não compila, mas chama um compilador que o terminal deve encontrar, e que o texto exato de uma mensagem distingue a falha de instalação da falha de invocação.

Compilar, executar e configurar

A aula Compilar, executar e configurar fixou o ciclo de editar, salvar, compilar, executar e ler, e o comando do curso. Distinguiu o erro, que impede o executável, do aviso, que o permite mas aponta código suspeito; ativou os detectores (o de erros de memória, AddressSanitizer, e o de comportamento indefinido, UndefinedBehaviorSanitizer), que vigiam a execução, e mostrou seus limites; e explicou que arquivo, compilador e console devem coincidir em UTF-8.

Anatomia de um programa

A aula Anatomia de um programa dissecou o programa mínimo: os cabeçalhos, que declaram cada dependência; main, ponto de entrada cujo valor é o código de saída; o namespace std; as instruções, os blocos e os comentários. Ensinou a ler as mensagens a partir da primeira e fixou o guia de estilo do curso.

Entrada, saída e erros

A aula Entrada, saída e erros pôs o programa em contato com o exterior: std::println escreve exatamente o que se pede, com especificações de formato, e std::cin lê e para no primeiro caractere que não serve. Uma leitura que tropeça em um caractere que não pode formar o número põe a variável em zero e deixa o fluxo em erro, em silêncio (um número que não cabe no tipo ou uma entrada esgotada deixam na variável outro valor, e a aula enumera esses casos); por isso a leitura se verifica. A aula encerrou a unidade classificando os erros pelo seu momento: de compilação, de ligação, de execução e de lógica.