1. O Conceito de I/O (Input & Output)

Na ciência da computação, todo fluxo de informação é categorizado sob a sigla I/O (Input/Output):

  • Entrada (Input): É o ato de introduzir dados vindos do mundo exterior para dentro da memória do computador. Exemplos de dispositivos de entrada: teclado físico, cliques do mouse, toques na tela do celular, microfone ou leitura de arquivos no disco.
  • Saída (Output): É o ato de devolver ao mundo exterior o resultado daquilo que a máquina processou. Exemplos de dispositivos de saída: monitor de vídeo, terminal de texto, caixas de som, impressoras ou gravação de relatórios.
Diagrama mostrando o fluxo de entrada de dados pelo teclado, processamento na memória RAM e CPU, e exibição da saída no terminal de vídeo
Figura 1: A ponte de comunicação completa: Dispositivos de Entrada → CPU e Memória RAM → Dispositivos de Saída.

2. Como Funciona o Comando `entrada()`: O Comportamento Bloqueante

Quando a CPU está executando um algoritmo linha por linha e encontra uma instrução como entrada(nome), acontece um fenômeno crucial que todo programador precisa compreender: a execução entra em estado de espera bloqueante.

O processador não "adivinha" o que o usuário vai digitar, nem pula para a linha seguinte. Ele literalmente congela a progressão do programa, abre o canal de escuta do teclado e aguarda pacientemente até que o usuário:

  1. Digite os caracteres desejados no teclado.
  2. Pressione a tecla Enter (que envia o sinal de confirmação de término).
Ilustração do comportamento bloqueante do comando entrada(): o código pausa na linha aguardando a digitação no terminal e só prossegue após o Enter
Figura 2: O comportamento bloqueante: o programa pausa na linha de entrada e só acorda para a próxima instrução após o sinal de Enter do teclado.

Assim que o Enter é pressionado, o valor digitado é convertido para o tipo correto e imediatamente gravado na "gaveta" de memória correspondente. Só então o programa desperta e avança para a próxima linha de comando.

3. A Armadilha Clássica: Texto Literal (Com Aspas) vs Variável (Sem Aspas)

O erro que mais confunde quem está dando os primeiros passos na programação é a diferença entre colocar ou não colocar aspas dentro do comando saida().

Grave esta regra de ouro:

  • Com Aspas "texto" (Literal): O computador não interpreta nem procura nada na memória. Ele imprime exatamente aquelas letras na tela, como um carimbo cego.
  • Sem Aspas nome (Identificador de Variável): O computador sabe que não deve imprimir a palavra "nome", mas sim ir até a memória RAM, abrir a gaveta chamada nome e exibir o conteúdo que estiver guardado lá dentro.
Diferença Prática na Saída COMPARAÇÃO
texto usuario = "Maria"

// Caso 1: Com aspas (imprime o texto fixo literalmente)
saida("usuario")  // Exibição na tela: usuario

// Caso 2: Sem aspas (busca o valor guardado na RAM)
saida(usuario)    // Exibição na tela: Maria

4. Concatenação de Texto: Criando Frases Dinâmicas sem Erro

Raramente você vai querer exibir apenas um número solto na tela. Em sistemas reais, nós explicamos o resultado para o usuário: em vez de mostrar apenas 25, mostramos "Você tem 25 anos.".

Juntar partes de texto fixo com valores de variáveis dinâmicas chama-se Concatenação. Na maioria das linguagens e no Portugol moderno, usamos o operador de soma + ou vírgulas entre os termos:

Diagrama demonstrando a anatomia de um comando saida() com concatenação de texto e a importância de incluir espaços internos para não colar palavras
Figura 3: A anatomia da concatenação: preste sempre atenção aos espaços internos dentro das aspas para evitar palavras grudadas na saída.

Cuidado com as Palavras "Coladas"!

O computador não coloca espaços automaticamente entre os pedaços de texto que você junta. Se você escrever saida("Você tem" + idade + "anos"), o terminal exibirá "Você tem25anos". Para que a frase fique natural e legível, coloque sempre um espaço antes de fechar as aspas do primeiro texto e um espaço logo após abrir as aspas do texto seguinte.

5. Algoritmo Completo: Diálogo Interativo com Teste de Mesa

Vamos analisar um algoritmo completo que solicita o nome e o ano de nascimento do usuário, calcula a idade aproximada e exibe uma saudação personalizada:

Algoritmo: Saudação Interativa e Cálculo de Idade LOGICABR.DEV
// 1. Leitura dos dados de entrada com prompt interativo
texto nome = entrada("Digite seu nome:");
numero anoNasc = entrada("Digite seu ano de nascimento:");

// 2. Processamento
numero idade = 2026 - anoNasc;

// 3. Saída formatada
saida("Olá, " + nome + "! Você tem aproximadamente " + idade + " anos.");

Se o usuário digitar primeiro "Carlos" e depois 2006, veja o rastreamento da execução:

Etapa Ação do Usuário / Sistema Estado da Memória RAM Terminal de Saída
1. entrada(nome) Usuário digita "Carlos" + Enter RAM[nome] = "Carlos" (aguardando)
2. entrada(anoNasc) Usuário digita 2006 + Enter RAM[anoNasc] = 2006 (aguardando)
3. Cálculo idade = 2026 - 2006 RAM[idade] = 20 (processando)
4. saida(...) Monta a frase e envia ao monitor (inalterada) Olá, Carlos! Você tem aproximadamente 20 anos.

Dica Prática de Usabilidade

Em programas reais de terminal ou console, sempre emita uma saida() com mensagem explicativa antes de chamar uma entrada() (por exemplo: saida("Digite o seu nome:")). Isso evita que o usuário olhe para uma tela preta vazia sem saber o que o programa está esperando.

6. As 4 Maiores Pegadinhas em Entrada e Saída (e Como Solucioná-las)

A camada de Entrada e Saída é a fronteira onde o código perfeito do programador colide com a imprevisibilidade do usuário humano. A seguir, destacamos as quatro falhas mais frequentes em testes de lógica:

1. A Falha do "Cursor Piscando no Vácuo"

Se você executar entrada(idade) sem um comando saida("Por favor, digite sua idade:") imediatamente anterior, o terminal exibirá apenas uma linha preta com o cursor piscando. O usuário pensará que o aplicativo travou ou que a página congelou, fechando a aplicação por frustração.

2. A Ilusão do Operador de Soma (+): Número vs Texto

O que acontece quando você faz saida("10" + "20") vs saida(10 + 20)?

  • Com aspas (textos): "10" + "20" resulta em "1020" (concatenação literal de caracteres).
  • Sem aspas (números inteiros): 10 + 20 resulta em 30 (operação aritmética na ALU da CPU).

3. O Erro da Falta de Espaçamento

Ao juntar textos e variáveis, lembre-se de que o computador não insere espaços automaticamente: "Olá," + nome imprimirá "Olá,Carlos" grudado. A forma correta é sempre prever o espaço dentro das aspas: "Olá, " + nome.

4. Digitação de Letras em Variáveis Numéricas

Se a variável foi tipada como numero e o usuário digita "vinte" por extenso em vez do algarismo 20, o programa dispara uma exceção fatal de conversão de tipos (Type Mismatch). No próximo módulo (Aula 04), aprenderemos como proteger variáveis contra esse tipo de falha.

7. Exercício Prático Resolvido: Divisão de Conta e Gorjeta

Vamos implementar um programa prático de utilidade real: um sistema para garçons de restaurante que solicita o valor total da comanda, calcula 10% de taxa de serviço (gorjeta) e divide a conta igualmente entre um grupo de amigos.

Algoritmo: Divisao_De_Conta_Restaurante LOGICABR.DEV
saida("=== SISTEMA DE CONTA DE RESTAURANTE ===");

// 1. Interação e Entrada de Dados com prompt
moeda valorConsumo = entrada("Informe o valor total do consumo dos pratos (R$):");
numero quantidadeAmigos = entrada("Informe a quantidade de pessoas para dividir a conta:");

// 2. Processamento Matemático
moeda valorGorjeta = valorConsumo * 0.10;
moeda valorTotalComGorjeta = valorConsumo + valorGorjeta;
moeda valorPorPessoa = valorTotalComGorjeta / quantidadeAmigos;

// 3. Saída de Dados com Recibo Detalhado
saida("----------------------------------------");
saida("Subtotal do Consumo: R$ " + valorConsumo);
saida("Taxa de Serviço (10%): R$ " + valorGorjeta);
saida("Total Geral a Pagar: R$ " + valorTotalComGorjeta);
saida("Valor individual por pessoa: R$ " + valorPorPessoa);
saida("Obrigado pela preferência e volte sempre!");

Teste de Mesa com Dados Reais

Simulando uma mesa com conta de R$ 200,00 dividida entre 4 amigos:

Etapa Lógica Entrada Fornecida Fórmula / Processamento Valor Armazenado Exibição no Terminal
Consumo 200.00 entrada(valorConsumo) valorConsumo = 200.00 -
Pessoas 4 entrada(quantidadeAmigos) quantidadeAmigos = 4 -
Cálculo Gorjeta - 200.00 * 0.10 valorGorjeta = 20.00 -
Total Geral - 200.00 + 20.00 valorTotalComGorjeta = 220.00 -
Divisão - 220.00 / 4 valorPorPessoa = 55.00 -
Recibo Final - saida(...) - "Valor individual por pessoa: R$ 55"

8. Perguntas Frequentes sobre Entrada e Saída (FAQ)

Por que a instrução entrada() interrompe a execução do programa?
Trata-se de uma operação chamada bloqueante e síncrona (Blocking I/O). Como o processador opera na ordem de bilhões de cálculos por segundo e o ser humano leva alguns segundos para digitar no teclado, o sistema operacional coloca o processo em estado de espera (sleep) para liberar o processador para outras tarefas, acordando o programa no exato milissegundo em que a tecla Enter é pressionada.
O que significam os termos industriais STDIN, STDOUT e STDERR?
Em todos os sistemas operacionais modernos (Unix, Linux, Windows), todo programa recebe três canais virtuais pré-abertos:
  • STDIN (Standard Input): Canal padrão de entrada, que por padrão é conectado ao teclado.
  • STDOUT (Standard Output): Canal padrão de saída para mensagens comuns e resultados, conectado à tela do monitor.
  • STDERR (Standard Error): Canal especializado de saída exclusivo para registrar erros e mensagens críticas do sistema, permitindo separar logs de falhas das saídas normais.
Posso ler mais de um dado com um único comando de entrada?
Em linguagens como C (com scanf) ou Python (com split()), é possível ler múltiplos valores separados por espaços. Em pseudocódigo educacional e no logicabr.dev, recomendamos sempre fazer chamadas separadas para cada variável com uma instrução explicativa antes de cada leitura para manter a clareza e evitar confusão do aluno.
Como programas com telas gráficas (janelas com botões) fazem entrada e saída?
Em programas com janelas (como navegadores ou aplicativos de celular), a entrada de dados não bloqueia a tela; em vez disso, ela utiliza um modelo orientado a eventos (Event-Driven). A interface gráfica aguarda o usuário clicar em um botão ou preencher um campo de formulário e dispara uma função que coleta o dado quando o evento ocorre.

Pratique I/O Agora Mesmo na IDE!

Teste o comando entrada() e veja o terminal interativo solicitar valores em tempo real no logicabr.dev.

Abrir IDE Online e Experimentar →