🎓 Aula 02

Estrutura Sequencial e E/S

Prof. Paulo Rettore

Universidade Federal de Lavras

GAC124 - Introdução aos Algoritmos

🎯 O que vamos aprender hoje?

📥 ⚙️ 📤

Atribuir e atualizar valores em variáveis
Construir expressões aritméticas simples em C++
Ler dados do usuário usando cin
Apresentar resultados usando cout
Organizar um programa completo em estrutura sequencial

🌊 Todo programa segue um fluxo

📥 Entrada

Dados fornecidos ao programa

Ex: informar duas notas

⚙️ Processamento

Cálculos e atribuições

Ex: calcular a média

📤 Saída

Resultados para o usuário

Ex: mostrar a média

📦 Atribuição coloca um valor na memória

Em C++, o operador de atribuição é o sinal de igualdade. Ele significa "recebe", e não "é igual a".

int idade; idade = 18; double altura = 1.72;

O lado direito é calculado primeiro; o resultado é então armazenado na variável que está à esquerda.

🔄 Uma nova atribuição substitui o valor

int pontos = 10; pontos = 25; pontos = pontos + 5;

Evolução da variável

10 → 25 → 30

Como funciona?

A expressão pontos = pontos + 5 usa o valor atual (25) para produzir e armazenar o novo valor (30).

🧮 Cinco operadores resolvem os cálculos

Operação	Operador	Exemplo	Resultado
Soma	`+`	`8 + 2`	`10`
Subtração	`-`	`8 - 2`	`6`
Multiplicação	`*`	`8 * 2`	`16`
Divisão	`/`	`8 / 2`	`4`
Resto	`%`	`8 % 3`	`2`

O operador de resto % trabalha exclusivamente com valores inteiros.

⚠️ Divisão inteira é uma armadilha comum

double a = 7 / 2; // a recebe 3.0 double b = 7.0 / 2; // b recebe 3.5

A operação é resolvida antes da atribuição. Se os dois operandos forem inteiros, o resultado da divisão também será inteiro.

Para manter a parte decimal, use pelo menos um operando de ponto flutuante (como 7.0 em vez de 7).

📝 Parênteses deixam a intenção explícita

double media = nota1 + nota2 / 2.0; // Incorreto para a média double media = (nota1 + nota2) / 2.0; // Correto

Ordem Básica

Parênteses
Multiplicação, divisão e resto
Soma e subtração

Regra Prática

Quando houver dúvida sobre a ordem de execução, use parênteses.

🧭 Precedência: resolva na ordem certa

X = A + B - C / D A = 18, B = 7, C = 6, D = 2

Passo a passo

1. Substitua: X = 18 + 7 - 6 / 2

2. Divisão primeiro: X = 18 + 7 - 3

3. Da esquerda para a direita: X = 25 - 3 = 22

Resposta

X = 22

Multiplicação, divisão e resto vêm antes de soma e subtração.

⚡ Operador composto: `+=`

int x = 7; x += 3;

x += 3 é uma forma curta de escrever x = x + 3.

Antes

x = 7

Depois

x = 7 + 3 = 10

Resultado final: x = 10

🔢 Pós-incremento e pré-incremento

Pós-incremento: usa, depois aumenta

int x = 4, y = 1; int z = x++ + y++;

Primeiro: z = 4 + 1 = 5

Depois: x = 5 e y = 2

Pré-incremento: aumenta, depois usa

int x = 4, y = 1; int z = ++x + ++y;

Primeiro: x = 5 e y = 2

Depois: z = 5 + 2 = 7

Leia com atenção: x++ e ++x não produzem o mesmo valor dentro da expressão.

⚡ Atualizações de forma curta

Forma Longa

saldo = saldo + 50; contador = contador + 1;

Forma Curta

saldo += 50; contador++;

Também existem -=, *=, /=, %= e --.

A forma curta deve ser usada somente quando continuar clara para quem lê.

📚 A biblioteca cmath oferece cálculos prontos

#include <cmath> double raiz = sqrt(25.0); // 5.0 double potencia = pow(2, 3); // 8.0 double modulo = abs(-7.5); // 7.5

sqrt() : Raiz quadrada
pow() : Potenciação
abs() : Valor absoluto (módulo)
ceil() : Arredondamento para cima
floor() : Arredondamento para baixo

📤 cout apresenta mensagens e valores

int idade = 18; cout << "Idade: " << idade << '\n'; cout << "Dobro: " << idade * 2 << '\n';

Textos fixos ficam entre aspas duplas
Variáveis e expressões ficam fora das aspas
O operador << encadeia as informações
endl ou '\n' geram uma quebra de linha

📥 cin lê dados para variáveis

int idade; cout << "Digite sua idade: "; cin >> idade;

O operador >> envia o valor digitado pelo usuário para a variável.

⚠️ Sempre declare a variável antes de realizar a leitura!

📥 Uma leitura pode preencher várias variáveis

double nota1, nota2; cout << "Digite duas notas: "; cin >> nota1 >> nota2;

⌨️

Os valores podem ser separados por espaço ou por Enter na hora da digitação.

💬

Uma mensagem com cout antes da leitura ajuda o usuário a entender o que deve informar.

✨ Formatação torna a saída mais clara

#include <iomanip> double preco = 19.5; cout << fixed << setprecision(2); cout << "Preço: R$ " << preco << '\n';

Saída gerada: Preço: R$ 19.50

Use <iomanip>, fixed e setprecision quando a quantidade de casas decimais importar.

📁 Arquivos e streams: dados que permanecem

Um arquivo permite guardar dados para que possam ser usados novamente depois que o programa termina.

Fluxo de texto

Os dados são tratados como caracteres, linhas e palavras. É fácil abrir e conferir o conteúdo.

Fluxo binário

Os bytes são gravados diretamente, sem tradução para texto. É útil para dados estruturados e arquivos maiores.

Em C++, a biblioteca <fstream> oferece os fluxos usados para trabalhar com arquivos.

🔁 Console e arquivos usam streams parecidos

Console	Arquivo	Função
`cin`	`ifstream`	Entrada / leitura
`cout`	`ofstream`	Saída / escrita
—	`fstream`	Entrada e saída

A ideia é familiar: assim como cin >> valor lê do teclado, arquivo >> valor lê do arquivo.

✍️ Escrevendo em arquivo com `ofstream`

#include <fstream> using namespace std; int main() { ofstream arquivo("notas.txt"); if (!arquivo) return 1; arquivo << "Ana 8.5\\n"; arquivo << "Bruno 7.0\\n"; arquivo.close(); }

Se não existir

O arquivo é criado.

Se já existir

O conteúdo é substituído, salvo se outro modo for usado.

📖 Lendo arquivo com `ifstream`

#include <fstream> #include <string> using namespace std; ifstream arquivo("notas.txt"); string nome; double nota; while (arquivo >> nome >> nota) { cout << nome << ": " << nota << '\\n'; }

Se o arquivo não existir, a abertura falha. Sempre confira o estado do stream antes de confiar nos dados.

🔄 `fstream`: ler e escrever

#include <fstream> using namespace std; fstream arquivo("dados.txt", ios::in | ios::out); if (arquivo) { // arquivo << dado; // escreve // arquivo >> dado; // lê }

Modos comuns

ios::in lê; ios::out escreve; ios::app acrescenta ao final.

Regra prática

Abra o arquivo com o fluxo que descreve a operação principal do programa.

⚠️ Cuidados antes de usar um arquivo

1. Confirme a abertura

Use if (!arquivo) ou is_open() antes de ler ou escrever.

2. Escolha o modo

ios::app acrescenta; abrir somente com saída pode substituir o conteúdo.

3. Verifique a operação

Teste o estado do stream e confirme se a gravação terminou corretamente.

Não use while (!arquivo.eof()) para controlar a leitura. Prefira testar a própria operação, por exemplo: while (arquivo >> valor).

🧭 Arquivos dentro de `switch-case`

Os casos de um switch não criam automaticamente um novo escopo. Use chaves em cada caso quando declarar um arquivo.

int opcao; cin >> opcao; switch (opcao) { case 1: { ofstream saida("dados.txt", ios::app); if (!saida) { cout << "Erro ao abrir"; break; } saida << "Ana;8.5\n"; break; } case 2: { ifstream entrada("dados.txt"); if (!entrada) { cout << "Erro ao abrir"; break; } string linha; while (getline(entrada, linha)) cout << linha << '\\n'; break; } default: cout << "Opcao invalida"; }

As chaves delimitam o escopo de cada declaração. O break evita cair no próximo caso, e a abertura deve ser verificada em cada operação.

🧾 Arquivos com separadores: formato CSV

Escrita

ofstream arquivo("alunos.csv"); arquivo << "nome;nota\n"; arquivo << "Ana;8.5\n"; arquivo << "Bruno;7.0\n";

O ponto e vírgula separa os campos de cada registro.

Leitura

ifstream arquivo("alunos.csv"); string linha; getline(arquivo, linha); // cabeçalho while (getline(arquivo, linha)) { cout << linha << '\\n'; }

Primeiro leia a linha inteira; depois separe os campos.

CSV é um formato de texto. O separador pode ser vírgula, ponto e vírgula ou outro caractere combinado pelo programa.

✂️ `getline()` e separadores

Além de ler uma linha completa, getline() pode parar em um delimitador específico.

#include <sstream> string linha = "Ana;8.5"; stringstream partes(linha); string nome, notaTexto; getline(partes, nome, ';'); getline(partes, notaTexto, ';');

Quando usar

Use getline() quando o texto tiver espaços ou quando precisar controlar o separador.

Atenção

Depois de cin >>, descarte o Enter pendente antes de chamar getline(cin, texto).

🔁 Ler e escrever em estruturas de repetição

ifstream entrada("valores.txt"); ofstream saida("pares.txt"); int valor; while (entrada >> valor) { if (valor % 2 == 0) saida << valor << '\\n'; } if (!entrada.eof()) cout << "A leitura terminou por erro.";

A repetição deve testar a leitura. Assim, cada valor válido é processado uma vez e o programa consegue distinguir fim de arquivo de uma falha de leitura.

🛤️ A estrutura sequencial executa na ordem escrita

1. Ler os dados

↓

2. Calcular o resultado

↓

3. Exibir o resultado

Não há desvios nem repetições: cada instrução é executada uma vez, de cima para baixo.

Uma sequência incorreta pode gerar um resultado incorreto mesmo quando cada linha está sintaticamente correta.

💻 Exemplo completo: Média de duas notas

#include <iostream> #include <iomanip> using namespace std; int main() { double nota1, nota2; cout << "Digite duas notas: "; cin >> nota1 >> nota2; double media = (nota1 + nota2) / 2.0; cout << fixed << setprecision(1); cout << "Média: " << media << '\n'; return 0; }

📖 Leia o código como uma pequena história

No exemplo da média:

1. Entrada

cin recebe as duas notas informadas pelo usuário.

2. Processamento

A expressão calcula a média e armazena na variável.

3. Saída

cout apresenta o resultado formatado na tela.

Essa decomposição ajuda a planejar a solução antes de programar.

🔄 Trocar valores exige preservar a informação

Forma Incorreta

a = b; b = a;

O valor original de a é perdido na primeira atribuição.

Forma Correta

int auxiliar = a; a = b; b = auxiliar;

A variável auxiliar salva o valor antes de ser sobrescrito.

🧹 Código legível reduz erros

Use nomes claros: media, nota1, precoFinal.
Indente blocos de código de maneira consistente.
Escreva uma instrução por linha.
Comente a intenção, não o óbvio.

// Calcula a média aritmética das duas avaliações double media = (nota1 + nota2) / 2.0;

🚫 Cinco erros comuns para evitar

Erro	Correção
Usar vírgula em decimal: `3,14`	Usar ponto: `3.14`
Ler antes de declarar a variável	Declarar a variável primeiro
Trocar `cin >>` por `cin <<`	Usar `>>` na entrada
Colocar variável entre aspas no `cout`	Deixar a variável fora das aspas
Esperar `3.5` da operação `7 / 2`	Usar `7.0 / 2`

🧩 Desafio: Preveja a saída

int a = 7; int b = 2; double x = a / b; double y = a / 2.0; a += 1; cout << a << " " << x << " " << y << '\n';

Antes de prosseguir, anote o valor final de a, x e y.

✅ Gabarito: Tipos mudam o resultado

Saída gerada: 8 3 3.5

a passa de 7 para 8 por causa de a += 1.
a / b usa dois inteiros e produz 3 (mesmo sendo armazenado em um double).
a / 2.0 inclui um valor decimal e produz 3.5.

📌 Quatro ideias para levar da aula

= armazena o resultado da direita na variável da esquerda.
O tipo dos operandos influencia o resultado de uma expressão.
cin recebe dados e cout apresenta resultados.
Um programa sequencial segue entrada, processamento e saída.

🧩 Prática extra: total de compra

Leia preço e quantidade e mostre o total com duas casas decimais.

double preco; int quantidade; cin >> preco >> quantidade; double total = preco * quantidade; cout << fixed << setprecision(2) << total;

Gabarito: inclua <iomanip> para usar fixed e setprecision(2).

Prática online opcional: beecrowd ou C++ Shell.

📚 Referências e materiais

Use estas fontes para consultas pontuais depois da aula:

Os slides completos, o Campus Virtual e o DREDD continuam sendo as fontes principais da disciplina.

⏭️ Próxima Aula

🔀

Estruturas Condicionais

Como fazer o programa escolher caminhos diferentes com if-else e switch-case.