Apostila Programação Básico CAP 1 e 2-UFV

Prévia do material em texto

UNIVERSIDADE FEDERAL DE VIÇOSA 
CENTRO DE CIÊNCIAS EXATAS 
DEPARTAMENTO DE INFORMÁTICA 
INF100 – INTRODUÇÃO À PROGRAMAÇÃO I
APOSTILA DE APOIO AO CONTEÚDO 
TEÓRICO
Prof. Marcos Henrique Fonseca Ribeiro
Prof. Vitor Barbosa Carlos de Souza
Prof. Salles Viana Gomes de Magalhães
Março/Abril de 2011
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
Sumário
Capítulo 1: Conceitos Básicos..............................................................................................................1
1. Arquitetura e Funcionamento Básicos de um Computador.........................................................1
1.1 Componentes de um Computador.........................................................................................3
1.1.1 Hardware.......................................................................................................................3
1.1.2 Software.........................................................................................................................6
1.1.2.1 Software Básico.....................................................................................................7
1.1.2.2 Aplicativos.............................................................................................................8
1.2 Sistemas Centrados em Computadores.................................................................................9
2. Conceitos Básicos Complementares..........................................................................................10
2.1 Bit e Byte............................................................................................................................10
2.2 Compilação e Interpretação.................................................................................................11
3. Introdução à Programação de Computadores............................................................................14
3.1 Algoritmos...........................................................................................................................15
4. Exercícios...................................................................................................................................18
Capítulo 2 – Introdução à Programação de Computadores e à Linguagem C++...............................21
1. O programa “Alo Mundo!”........................................................................................................22
2. Compilação do código-fonte e execução do programa..............................................................26
3. Comentários: objetivo e como usar...........................................................................................29
4. Variáveis.....................................................................................................................................30
4.1 Declaração de variáveis.......................................................................................................30
4.2 Regras para nomeação de variáveis....................................................................................34
5. Expressões aritméticas...............................................................................................................35
5.1 Operadores especiais...........................................................................................................38
5.2 Divisão de números inteiros................................................................................................39
6. Leitura de valores digitados pelo usuário..................................................................................40
7. Definição de buffer, comandos endl e flush..............................................................................42
8. Exercícios...................................................................................................................................44
Lista de Figuras
Figura 1. Esquema Básico de Funcionamento da Arquitetura de um Computador..............................4
Figura 2. Visão de um Sistema Centrado em Computador.................................................................10
Figura 3. Processo simplificado de criação, compilação e execução de um programa em C++........13
Figura 4. Do problema à sua solução, utilizando computador...........................................................15
Figura 5. Exemplo da representação de algoritmos por fluxograma..................................................18
Lista de Tabelas
Tabela 1. Utilizando um byte para representar números inteiros.......................................................11
Tabela 2. Tipos de Dados Básicos em C++........................................................................................31
Tabela 3. Valores representáveis em cada tipo de dado em C++........................................................32
Tabela 4. Operadores aritméticos em C++.........................................................................................36
Tabela 5. Precedência de operadores em C++....................................................................................37
Tabela 6. Exemplos de valores de expressões em C++......................................................................38
Tabela 7. Operadores especiais...........................................................................................................38
Tabela 8. Operadores de incremento e decremento em C++..............................................................39
Tabela 9. Uso de múltiplos cin...........................................................................................................41
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
Capítulo 1: Conceitos Básicos
Este Capítulo traz uma breve introdução aos conceitos básicos relativos a temas básicos 
para o andamento do curso, como o funcionamento de um computador, os conceitos de 
algoritmos e programas de computador, dentre outros. Vale ressaltar também que figuras 
ilustrativas de componentes e equipamentos aqui citados podem ser encontrados nas 
transparências (slides) utilizadas em sala aula e disponibilizadas juntamente com este 
material.
1. Arquitetura e Funcionamento Básicos de um Computador
Segundo o mundialmente conhecido site Wikipedia1, um computador: “é uma máquina 
capaz de variados tipos de tratamento automático de informações ou processamento 
de dados. Exemplos de computadores incluem o ábaco, a calculadora, o computador 
analógico e o computador digital. Um computador pode prover-se de inúmeros atributos, 
dentre eles armazenamento de dados, processamento de dados, cálculo em grande 
escala, desenho industrial, tratamento de imagens gráficas, realidade virtual, 
entretenimento e cultura.
No passado, o termo já foi aplicado a pessoas responsáveis por algum cálculo. 
Em geral, entende-se por computador um sistema físico que realiza algum tipo de 
computação. Existe ainda o conceito matemático rigoroso, utilizado na teoria da 
computação2.
Assumiu-se que os computadores pessoais e laptops são ícones da Era da 
Informação; e isto é o que muitas pessoas consideram como "computador". Entretanto, 
atualmente as formas mais comuns de computador em uso são os sistemas embarcados, 
pequenos dispositivos usados para controlar outros dispositivos, como robôs, câmeras 
1 Disponível em http://pt.wikipedia.org/wiki/Computador, acessado em 10/03/2011.
2 Este conceito matemático rigoroso citado no texto implica em uma série de premissas matemáticas e uma discussão 
ampla sobre a natureza dos problemas que poderiam ser resolvidos por um computador. Tal discussão, no entanto, 
foge ao escopo desta disciplina. Desta forma, o conceito formal de computador, do ponto de vista da Teoria da 
Computação não é apresentado neste material.Por esta razão, a apostila se atém ao conceito informal aqui 
apresentado.
Página 1
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
digitais ou brinquedos.”
Independente da forma em que se apresenta ou é encontrado, todas as variantes 
de computador precisam de um elemento fundamental para seu funcionamento: (pelo 
menos) um programa que seja capaz de conduzir suas ações/operações de acordo com 
determinados estímulos recebidos, fornecendo respostas previamente previstas neste(s) 
programa(s). Simplificando o que foi visto até aqui, um computador3 poderia ser 
compreendido como uma máquina que pode ser programada para receber dados, 
processá-los, transformá-los em informação útil e/ou armazená-los.
Ainda assim diversos dispositivos que são comuns ao cotidiano moderno das 
pessoas ainda poderiam ser enquadrados neste conceito. Um exemplo são as máquinas 
automáticas de vendas de refrigerantes. Elas aguardam constantemente por entradas de 
dados específicas (inserção de dinheiro seguida da seleção do refrigerante, por meio de 
botões), analisam (processam) estes dados recebidos e os “transformam” em uma 
resposta, que é materializada no acionamento dos dispositivos que liberam a bebida 
desejada. No entanto, a máquina pode apresentar como resposta informações que não 
necessariamente são a liberação do refrigerante como, por exemplo, uma mensagem em 
um pequeno visor informando que o refrigerante escolhido não está disponível no estoque 
interno do aparelho, devolvendo o dinheiro ao cliente, deixando-o livre para uma nova 
escolha ou para desistir da bebida.
Note que no exemplo anterior a máquina de refrigerantes toma certas decisões de 
acordo com os dados de entradas e informações internas ao equipamento (nível de 
estoque) e pode produzir respostas diferentes, para cada situação, ao usuário. Este 
processo pode ser observado em inúmeros equipamentos eletrônicos modernos, ou seja, 
nos computadores. Desta forma, nossos computadores demandam basicamente alguns 
grupos de elementos, diferenciados quanto ao seu papel dentro dos mesmos. 
Basicamente, necessitam de dispositivos que realizam entradas e saídas de 
dados/informações, capacidade de reter, mesmo que temporariamente, algumas 
informações, dispositivos para processar dados e um programa que determinará seu 
comportamento diante de um conjunto pré-estabelecido de condições. Portanto, nas 
próximas seções, veremos estes componentes do computador, bem como seu papel 
dentro do esquema de funcionamento básico do mesmo.
3 Deste ponto em diante, consideraremos para o conceito de computador a noção de computador eletrônico, baseado 
no senso comum sobre a que tipo de dispositivo se trata tal conceito.
Página 2
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
1.1 Componentes de um Computador
Pode-se dizer que um computador é formado por duas categorias principais de 
elementos: hardware e software. A parcela relativa ao hardware constitui a parte física 
do computador, ou seja, é todo o equipamento que pode ser visto no computador, estando 
ele em funcionamento ou não. Um equipamento de hardware específico pode ser de 
natureza eletrônica, eletromagnética, mecânica, ótica etc. Já o software, diz respeito à 
parte lógica, ou abstrata, do computador, isto é, refere-se a programas que utilizam o 
hardware estrategicamente, de modo a tornar o computador uma ferramenta útil.
Primeiramente, estudaremos o hardware do computador, por meio de duas visões 
distintas, uma teórica, que esquematiza o funcionamento geral do computador e uma 
prática, mapeando para componentes físicos os elementos teóricos apresentados 
anteriormente.
1.1.1 Hardware
Visão teórica:
De forma bastante sucinta, o funcionamento básico de um computador consiste 
em um processador, que realiza as operações de processamento de dados propriamente 
ditas que acessa e/ou fornece dados para um dispositivo de memória principal. Este 
dispositivo é o único a interagir diretamente com o processador central do computador, 
portanto, somente ele é capaz de fornecer ou receber dados cuja origem ou destino são o 
processamento central da máquina.
Assim, para que a interação com o usuário ou outros equipamentos seja feita, é 
necessária uma interação entre a memória interna (principal) do computador e 
dispositivos de entrada e/ou saída de dados. Assim, é possível que um documento de 
texto que esteja sendo editado por um usuário seja impresso em uma impressora, uma 
vez que os dados do documento são transferidos da memória principal para o dispositivo 
externo de saída, a impressora. Da mesma maneira, ao digitar em um teclado, o usuário 
enviou, por meio deste dispositivo de entrada de dados, informações para “dentro” do 
computador. O que de fato acontece é que os dados oriundos do teclado são primeiro 
transferidos para a memória principal para somente aí serem processados pelo Editor de 
Página 3
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
Textos. Da mesma maneira, ao se abrir um documento que reside no disco rígido da 
máquina, o que é feito, inicialmente, é uma transferência deste arquivo do disco rígido 
para a memória principal do computador. As implicações disto e mais detalhes do 
funcionamento destes componentes do hardware podem ser vistos a seguir, na Figura 1.
Figura 1. Esquema Básico de Funcionamento da Arquitetura de um Computador
• Processador : também chamado de CPU (Central Processing Unit – 
Unidade de Processamento Central), é o responsável pela execução das 
operações no computador. Exemplos: Intel 80486, Pentium, Core 2 Duo, 
Core 2 Quad; AMD Athlon, Opteron, Turion, etc.
• Memória principal : também chamada de memória RAM (Random Access 
Memory – Memória de Acesso Aleatório), é responsável por armazenar os 
programas durante sua execução (processos). A memória RAM é volátil, ou 
seja, a informação desaparece da memória principal quando o computador 
é desligado. Para armazenar dados de forma permanente, são utilizados 
alguns dispositivos de entrada e saída (chamados de memórias 
secundárias) tais como os discos rígidos.
• Dispositivos de entrada e saída (E/S – ou I/O, do inglês Input/Output ) : são 
todos e quaisquer dispositivos que não pertencem à arquitetura interna 
composta por processador e memória principal. Os dispositivos de E/S 
servem para fazer a comunicação ser humano–máquina ou 
armazenamento de dados. Exemplos: teclado, monitor de vídeo, unidade 
Página 4
Barramentos Externos
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
de CD/DVD, disco rígido, pendrive, impressoras, leitores de código de 
barras etc.
• Barramentos : meios de comunicação que servem para interligar as partes 
que compõem a arquitetura básica (barramento interno) e os dispositivos 
de E/S (barramentos externos).
• Memória Somente Leitura ( Read-Only Memory – ROM) : existe ainda um 
outro tipo de memória, que contém dados e uma espécie de programas 
registrados permanentemente pelo fabricante do equipamento. Seu 
conteúdo não pode ser alterado pelo usuário, à exceção de algumas 
funções ou por meio de procedimentos especiais e sua finalidade é 
carregar funções básicas e/ou principais do computador de forma que 
estas sempre sejam acessíveis e não se apaguem ao interromper a 
alimentação de energia da máquina. É também responsável por ativar os 
principais componentes do computador, por fazer teste de diagnósticos de 
problemas, teste na memória principal, dentre outras tarefas básicas que 
precedem a utilização do computador pelo usuário.Visão Prática:
• Gabinete : composto pelo gabinete propriamente dito e por uma fonte de 
alimentação. Dentro do gabinete fica a placa-mãe, onde se localiza o 
processador, o(s) chip(s) de memória e os barramentos, com slots (fendas) 
para permitir o encaixe de placas com interfaces para a conexão com 
dispositivos externos (ex: monitor de vídeo, placa de rede etc.). Atualmente 
muitas placas-mãe incorporam algumas destas placas para conexão de 
dispositivos externo. Tais placas incorporadas são denominadas on-board. 
O gabinete possui também slots para a instalação de disco(s) rígido(s) e 
alguns dispositivos que são visíveis externamente, tais como, os drives de 
disquete, de CD e de DVD.
• Monitor de vídeo : é o dispositivo de saída responsável pela exibição das 
informações para o usuário. Atualmente existem monitores de vídeo 
sensíveis ao toque, portanto funcionam também como dispositivo de 
entrada.
Página 5
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
• Teclado : dispositivo de entrada com um conjunto pré-definido de caracteres 
(letras, números, sinais de pontuação). É usado para fornecer informações 
textuais ao computador. 
• Mouse : é um dispositivo de entrada usado em interfaces gráficas e é 
associado a um apontador. Ao movimentar o mouse, o apontador faz o 
movimento correspondente na tela gráfica do monitor de vídeo. 
Basicamente, seu papel está em informar ao computador um par de 
coordenadas da tela e um evento que ali aconteceu, como o pressionar um 
dos botões do mouse ou o pressionar intermitente de um destes botões. A 
partir desta informação, o computador interpretará o que deverá ser feito, 
de acordo com a programa que está sendo utilizado.
1.1.2 Software
Conforme mencionado anteriormente, os softwares podem ser vistos como a parte 
abstrata ou lógica de um computador. São representados logicamente por meio de 
algoritmos, que são vistos mais adiante neste material, e introduzidos no computador por 
meio da conversão de algoritmos em programas de computador.
São os programas de computador os responsáveis pela transformação dos dados 
de entrada em informações de saída. Assim, um programa pode ser visto como uma 
sequência de comandos que detalham todas as ações que um computador deve realizar, 
ou seja, um conjunto de instruções para ações específicas do computador. Desta 
maneira, um computador executa precisamente o que está determinado em um 
programa.
O programa contém instruções para a máquina, não para o usuário. A partir do 
momento em que um programa é solicitado para execução, o computador processa suas 
instruções passo a passo, começando pela primeira instrução e seguindo a ordem pré-
estabelecida no programa.
Esta seção apresenta o conceito de software subdividido em duas categorias, a 
de software básico, ou Sistema Operacional e a de Aplicativos, vistas a seguir.
Página 6
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
1.1.2.1 Software Básico
O Software Básico, ou Sistema Operacional (SO) é o software que controla o 
funcionamento do computador, sendo responsável por duas tarefas fundamentais que 
são: reconhecer e controlar o funcionamento do hardware e fazer a interação com o 
usuário. Desta maneira, pode-se dizer, a grosso modo, que o principal objetivo de um 
Sistema Operacional é tornar o uso do computador mais fácil para os usuários.
Uma parte importante dos SOs é o chamado núcleo, ou kernel. Este 
corresponde à porção do SO que gerencia o sistema operacional como um todo, 
interagindo diretamente com o hardware e é carregado do disco rígido para a memória 
quando o computador é inicializado. Também é responsável por carregar do 
armazenamento em disco outros programas auxiliares do sistema operacional, quando 
necessário. Estes outros programas são chamados de não-residentes e, em grande parte 
das vezes, são responsáveis por tarefas relacionadas à interação com o usuário.
Alguns exemplos de sistemas operacionais são: Windows (Vista, 7, 2003, XP, 
2000, ME, 98 etc.), Linux (Debian, Ubuntu, Red Hat, Mandriva, Slackware, Fedora, etc), 
MS-DOS, Solaris, AIX, FreeBSD, MAC-OS, entre outros.
Os sistemas operacionais podem ter interface de texto ou gráfica, sendo possível 
utilizá-las em conjunto. Em uma interface gráfica, o usuário pode executar muitas ações 
utilizando apenas o mouse, através da interação com imagens na tela, que representam 
uma série de conceitos e/ou ações, como os ícones, que podem representar um arquivo 
de determinado tipo, um atalho para pastas ou até mesmo um atalho para a execução de 
um software. Os botões, presentes em boa parte dos softwares com interface gráfica hoje 
em dia, normalmente são imagens que representam uma analogia a botões de 
equipamentos físicos, rotulados com ícones que indicam a ação que será executada ao 
se “clicar” naquele objeto na tela.
Quando apenas a interface de texto está disponível, o usuário deve conhecer os 
comandos necessários para realizar as operações desejadas. Isto faz com que a 
utilização de um Sistema Operacional por meio de sua interface de texto exija mais 
treinamento/capacitação por parte do usuário. No entanto, existem contextos onde a não 
presença da interface gráfica pode ser importante como, por exemplo, quando há alguma 
limitação dos recursos computacionais disponíveis e a economia de utilização de memória 
Página 7
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
principal gerada pelo não carregamento dos elementos da interface gráfica pode ser 
significativa para o bom desempenho do sistema. Alguns exemplos de comandos do SO 
Linux são: mkdir (criação de pastas), rmdir (remoção de pastas), rm (remoção de arquivos 
e/ou pastas), cd (mudança de pasta), ls (listagem de conteúdo de pastas), pwd (exibição 
da pasta atual), entre outros.
1.1.2.2 Aplicativos
Aplicativos são softwares desenvolvidos para realizar uma tarefa ou um conjunto de 
tarefas relacionadas a uma área específica. Por exemplo, existem aplicativos distintos 
para tarefas distintas como edição de texto, imagem, som, Engenharia Civil, Economia, 
Química, Sequenciamento de DNA etc.
Conforme mencionado anteriormente, existem aplicativos que fazem parte do 
pacote do sistema operacional. Porém compõem uma gama bem maior de aplicativos 
aqueles produzidos por terceiros, em que se pode instala-los em um computador, via seu 
sistema operacional. Por esta razão, na grande maioria dos casos, um aplicativo, ou uma 
versão dele só funciona em um computador com um sistema operacional específico, pois 
seu projeto visa a utilização naquele SO específico. Alguns fabricantes de software 
produzem versões de seus produtos para diversos SOs diferentes, ampliando assim, seu 
mercado consumidor.
Para que se produza um aplicativo é necessário conhecer uma linguagem de 
programação, ter um editor de textos para que se escreva o código do programa naquela 
linguagem e que se tenha um compilador, interpretador ou algo semelhante, para 
interpretação do código escrito pelo programador e a geração de um programa ou a 
execução direta do mesmo. Comumente, fabricantes de softwares ligados à programação 
de computadores disponibilizam pacotes de produtos que integram vários elementos úteis 
ao desenvolvimento de programas de computador de forma integrada, como editores de 
texto com recursos específicos para a linguagem com a qual se está trabalhando, 
analisadores de erros nos códigos, ferramentas para testes, ferramenta para geração de 
programas, documentação de ajuda etc.
Vale ressaltar que a disciplina alvo deste material tem comoobjetivo a introdução 
à programação de computadores, possibilitando com que o aluno seja capaz de criar 
aplicativos simples e, ao mesmo tempo, úteis para solucionar problemas específicos de 
Página 8
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
sua área de formação. Desta maneira, o foco deste material está em prover ao estudante 
a base teórica para o desenvolvimento de aplicativos que contribuam para automatização 
de tarefas em sua futura área de atuação profissional. A linguagem abordada neste 
documento é a linguagem C++. Portanto, os exemplos de programas dados nas seções e 
capítulos futuros estarão nesta linguagem de programação, salvo o contrário seja 
destacado no texto antes de determinado exemplo que não siga esta regra.
1.2 Sistemas Centrados em Computadores
Com base nos elementos vistos aqui e se introduzirmos pessoas no conceito de um 
“Sistema Centrado em Computador”, isto é, sistemas focados na utilização de 
computadores, mas que incorporam outros elementos que não estes, podemos classificar, 
basicamente, as pessoas que interagem com estes sistemas em duas categorias.
Usuários. São aquelas pessoas que simplesmente adquirem e utilizam aplicativos 
e/ou fazem uso dos sistemas disponibilizados pelo Sistema Operacional em uso no 
computador em questão.
Programadores. São as pessoas que desenvolvem aplicativos, isto é, criam 
programas de computador. Vale ressaltar que programadores também são usuários, uma 
vez que para criar seus aplicativos podem vir a utilizar outros aplicativos como suporte ao 
seu trabalho como, por exemplo, um editor de texto que foi adquirido para a criação de 
códigos de programas. Destaca-se, também, que são programadores que desenvolvem o 
código correspondente aos programas que compõem o próprio Sistema Operacional da 
máquina.
Unindo todos os principais elementos vistos nas seções 1.1 e 1.2 em um único 
modelo de um sistema, tem-se a Figura 2 como síntese do que foi visto, em termos de um 
sistema de computador.
Antes de passar para o tema da Programação de Computadores, é necessário, 
entretanto, que alguns conceitos adicionais relacionados à Informática sejam vistos, para 
melhor entendimento por parte do leitor.
Página 9
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
Figura 2. Visão de um Sistema Centrado em Computador
2. Conceitos Básicos Complementares
Esta seção tem como objetivo apresentar um conjunto de conceitos, de diversas 
naturezas, importantes para a programação de computadores. A fim de evitar a geração 
de um número grande de pequenas seções, compilou-se estes conceitos em uma única 
seção. Assim, cada conceito é trazido aqui de forma estanque, sem necessariamente 
haver conexão lógica e/ou conceitual com os demais conceitos da Seção 2.
2.1 Bit e Byte
Um bit é a unidade básica de armazenamento do computador. Seu nome vem de Binary 
Digit e possui um duplo sentido em inglês, uma vez que bit quer dizer “pedacinho”, ou 
pequena porção. Um bit pode assumir apenas 2 valores distintos, ou seja, o bit é binário. 
Esses 2 valores podem ser representados de diversas formas mas geralmente são 
utilizados os números 0 e 1 ou os termos desligado e ligado. É importante destacar que 
toda a informação contida e processada em um computador é convertida para sequências 
de dígitos 1 e 0. Assim, existem diversos mecanismos para se identificar onde começam e 
terminam subsequências dentro de uma grande sequência, se um conjunto de bits 
representa um caracter, um número inteiro ou outro tipo de dado qualquer. No entanto, 
para o contexto desta disciplina, o importante é saber identificar o bit enquanto unidade 
básica de armazenamento no computador.
Um byte é o conjunto de 8 bits. Um bit é binário, isto significa que cada posição 
Página 10
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
do byte pode assumir 2 valores distintos: 0 ou 1. Desta maneira, a primeira posição de um 
byte pode ter 2 valores possíveis. Para cada um destes valores, a segunda posição do 
byte pode assumir novamente 2 valores: 0 ou 1, resultando em 4 combinações distintas 
de sequências (00, 01, 10, 11). Assim, para as duas primeiras posições do byte, existem 4 
(2 x 2 = 22) valores que podem ser armazenados. Se um byte possui 8 bits em sequência, 
logo pode armazenar 28 , ou seja, 256 valores distintos. A Tabela 1 ilustra como um byte 
pode ser utilizado para representar alguns dos 256 números inteiros diferentes que 
podem ser representados em um byte.
Número Byte Correspondente
0 00000000
1 00000001
2 00000010
... ...
255 11111111
Tabela 1. Utilizando um byte para representar números inteiros
Alguns dos múltiplos mais utilizados do byte são: Kilobyte (1024 = 210 bytes), 
Megabyte (1024*1024 = 220 bytes), Gigabyte ( 230 bytes), Terabyte ( 240 bytes), 
Petabyte etc.
2.2 Compilação e Interpretação
Conforme visto na seção anterior, um computador só é capaz de processar sequências de 
números 0 ou 1. Desta forma, programas de computador também precisam ser 
representados desta maneira para que sejam executados pelo computador. No entanto 
não é prático nem produtivo para os programadores aprender a converter suas ideias e 
lógica de instruções em sequências de bits. As linguagens de programação são 
desenvolvidas para que pessoas sejam capazes de se expressar de forma sucinta, 
sistematizada e não ambígua, sob forma de instruções, para que um computador as 
execute. Assim, existem softwares especializados em interpretar as instruções passadas 
por programadores, em linguagens de programação chamadas de “linguagens de alto 
Página 11
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
nível” e converte-las em sequências binárias que são executáveis por um processador 
central. Estes softwares são chamados compiladores.
Portanto, compilação é o processo pelo qual um código-fonte, escrito em uma 
determinada linguagem de programação de alto nível, é traduzido para uma linguagem de 
máquina (sequências de bits), gerando um arquivo executável. Vale notar que é 
fundamental o uso de um compilador específico para a linguagem em que se está 
programando para permitir que o processador execute as tarefas descritas no programa.
Assim, como esta apostila aborda o uso da linguagem de alto nível C++, é 
necessário que se utilize compiladores projetados especificamente para análise e geração 
de programas executáveis a partir desta linguagem. Existem diversos compiladores, 
distribuídos gratuitamente ou não, para a linguagem C++. Durante as aulas práticas e 
estudos da disciplina INF 100, recomenda-se o uso do compilador g++, quando se 
utilizando o Sistema Operacional Linux e o Dev-C++, quando se utilizando o SO 
Windows. Ambos são de distribuição gratuita e podem ser facilmente encontrados na 
Web, onde estão disponíveis para download. Outros exemplos de linguagens compiladas 
são C, Pascal, Fortran etc.
Diferenciamos o processo da interpretação do processo de compilação quando o 
software responsável pela geração do programa executável, ao invés de analisar o 
código-fonte inteiro desenvolvido pelo programador e somente depois da análise completa 
gerar um programa executável inteiro, o interpretador lê o código-fonte instrução por 
instrução e a converte e executa passo-a-passo, não gerando um programa executável ao 
final do processo, isto é, o código-fonte vai sendo executado à medida em que é lido e 
analisado. São exemplos de linguagens interpretadas PHP, Perl e Javascript.
Uma das mais famosas linguagens de programação, a linguagem Java, é de 
natureza híbrida, tendo partedo processo de geração de código executável compilada e 
parte interpretada.
A Figura 3 ilustra, de forma simplificada, o processo de criação, compilação e 
execução de um programa na linguagem C++. O processo representado pela figura pode 
ser descrito, de forma sucinta em oito passos, explicados a seguir.
Página 12
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
Figura 3. Processo simplificado de criação, compilação e execução de um programa em C++
1. Inicialmente, o programador interage com um editor da linguagem C++ para a 
escrita do programa (código) do aplicativo em desenvolvimento;
2. O resultado, após considerado pronto, ou parcialmente pronto, para compilação é 
um arquivo de texto contendo as instruções digitadas pelo programador, na 
linguagem C++. Este arquivo terá seu nome terminado com .cpp, que é o tipo de 
arquivo associado aos códigos-fonte da linguagem em questão;
3. O programador deverá interagir, agora, com o compilador de C++, a fim de gerar 
um programa executável, isto é, seu aplicativo. Deverá informar ao compilador, 
minimamente, o nome do arquivo que contém o código-fonte de seu aplicativo. 
Poderá também informar uma série de outros parâmetros para personalizar e/ou 
otimizar o programa resultante como, por exemplo, qual nome terá o arquivo 
executável do programa;
4. O compilador carrega o arquivo do código-fonte informado pelo programador;
5. O compilador analisa o código-fonte carregado em busca de erros de escrita e de 
Página 13
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
outras natureza;
6. Em caso de sucesso, o compilador gera um arquivo binário (sequências de bits) 
que pode ser executado diretamente, isto é, gera um programa de computador 
executável. Em outras palavras, o aplicativo desenvolvido pelo programador;
7. Sendo seu programa um aplicativo, o programador pode interagir diretamente com 
o mesmo, para que este execute a(s) tarefa(s) para a(s) qual(is) foi projetado;
8. Da mesma forma, um outro usuário qualquer poderá também interagir diretamente 
com o programa executável gerado, sem que haja necessidade de realizar 
nenhuma etapa anterior do processo, bastando que ele tenha acesso ao aplicativo 
final, resultante dos passos 1 a 6.
3. Introdução à Programação de Computadores
Pode-se iniciar o estudo da programação de computadores analisando, inicialmente, o 
contexto onde a mesma está inserida. Conforme já mencionado, pode-se projetar um 
programa de computador para se efetuar tarefas específicas que auxiliem os usuários em 
atividades de seu interesse. Em muitas situações, estas tarefas são rotineiras, 
trabalhosas, lentas, complexas, precisas demais ou simplesmente acontecem em 
quantidades impraticáveis para um ser humano desempenhar. Os computadores podem 
auxiliar os seres humanos nas mais diversas tarefas, como auxilia-lo na análise de dados 
de vendas em um supermercado para tomar decisões de marketing, calcular a trajetória 
de um míssil, controlar um estoque de uma loja ou simplesmente ordenar dados que 
estão armazenados em seu disco rígido. Independente de como é a tarefa, o computador 
entra para auxiliar o usuário na solução de um problema. 
Partindo deste princípio, o desenvolvimento de um software ou aplicativo é 
geralmente precedido da análise de um problema e da elaboração de uma solução 
descritiva para o mesmo. Esta solução pode ser representada de diversas formas, como 
uma descrição textual, um diagrama, um conjunto de passos em uma terminologia pré-
definida, entre outros. Uma das formas de se representar uma solução descritiva para um 
problema chama-se algoritmo. Antes de elaborar este conceito, deve-se ressaltar que a 
descrição algoritmica de um problema é facilmente convertida para um programa de 
computador, escrito em uma linguagem qualquer, que posteriormente poderá se tornar, 
depois do processo visto na seção anterior, um aplicativo que conterá a solução (ou parte 
Página 14
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
dela) automatizada para o problema. O quanto desta solução poderá ser automatizada, 
em que nível de inteligência e outras características dependerão de uma série de fatores 
como a natureza do problema, a capacidade de se representa-lo sob a forma de um 
algoritmo, a competência do programador, dentre muitos outros. A Figura 4, a seguir, 
esquematiza o processo ao qual esta seção se refere, ao se partir do problema até se 
chegar na solução deste (ou de parte deste) por meio do uso de programas de 
computadores.
Figura 4. Do problema à sua solução, utilizando computador
Assim, antes de se falar em programas de computadores, é interessante que se 
trabalhe o conceito de algoritmo, como forma de representação para soluções descritivas 
de um problema.
3.1 Algoritmos
Algoritmos fazem parte do dia a dia das pessoas. As instruções para o uso de 
medicamentos, as indicações de como montar um aparelho ou uma receita de culinária 
são alguns exemplos de algoritmos. Um algoritmo pode ser visto como uma sequência de 
ações executáveis para a obtenção de uma solução para um determinado tipo de 
Página 15
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
problema.
Uma outra visão para o conceito de algoritmos é “Sequência finita de instruções 
bem definidas e não ambíguas, cada uma das quais podendo ser executada 
mecanicamente num período de tempo finito e com uma quantidade de esforço finita”.
Programar é basicamente estruturar dados e construir algoritmos. De acordo com 
Wirth (1976), programas são formulações concretas de algoritmos abstratos, baseados 
em representações e estruturas específicas de dados. Em outras palavras, programas 
representam uma classe especial de algoritmos capazes de serem seguidos por 
computadores.
Um programa de computador, por ser escrito em uma linguagem destinada a esse 
fim, guarda algumas semelhanças com as ditas “linguagens naturais”, como inglês, 
francês, português etc. Uma semelhança importante está na escrita correta de suas 
expressões (instruções). Assim como em português, o descuido com a escrita pode 
causar erros que prejudicam a execução correta do programa resultante da compilação 
ou até mesmo um erro na própria compilação.
Independente da linguagem na qual o programador escreve, todas têm regras que 
regulamentam o uso das palavras e da pontuação. Essas regras são chamadas de 
sintaxe da linguagem. Se alguém perguntar, "Como na chego loja eu?", em português, a 
maioria das pessoas que dominam este idioma vai entender o que queria ser dito, ainda 
que não se tenha usado uma sintaxe correta. No entanto, computadores não possuem a 
mesma capacidade de discernimento e dedução que seres humanos. A menos que a 
sintaxe seja perfeita, o computador não é capaz de interpretar nada da instrução da 
linguagem de programação. Ou seja, ou uma instrução está escrita de modo perfeito ou o 
computador não sabe o que queria ser dito.
Mesmo em português, algumas situações relativas à pontuação ou à ortografia 
podem gerar alguma “armadilhas” na interpretação, gerando resultados inesperados. Por 
exemplo, a frase “Se você pode vir aqui em casa? Agora não preciso sair.” e a frase “Se 
você pode vir aqui em casa? Agora não, preciso sair.” se diferem por uma mera vírgula, 
mas ambas possuem significados opostos. Outro exemplo está nas frases Diga agora: 
“quero sair” ou Diga: “agora quero sair”, onde a simples troca de posições dos sinais de 
pontuação e da aspas mudam sutilmente o sentido da frase. Ainda, a palavra “ouviram”, 
se escrita equivocadamente como “ouvirão”, pode mudar completamente,dependendo do 
Página 16
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
contexto, o tempo ao qual uma sentença se refere. Enfim, se um ser humano pode se 
equivocar ao interpretar uma frase (sentença, instrução) mal formulada, é justo pensar 
que um computador, com capacidade de raciocínio bem mais limitada exija sintaxe muito 
mais rígida em suas instruções.
Assim, para criar um programa computacional, o programador inicialmente 
precisa escolher uma linguagem de programação para que ele possa dizer ao 
computador, através dessa linguagem, o que o mesmo deve fazer. Nesta disciplina 
usaremos a linguagem C++ por ser uma linguagem que inclui os principais conceitos de 
programação e pode ser utilizada como base para o aprendizado de várias outras 
linguagens.
Tendo sido escolhida a linguagem de programação, pode-se escrever o código 
referente ao programa que se deseja. Conforme já mencionado, esse código é um arquivo 
de texto simples que contém várias instruções definidas pela linguagem utilizada, de 
maneira que um conjunto de instruções não possa gerar ambiguidades em sua 
interpretação pela máquina.
Outra questão relacionada à escrita correta de um programa está ligado à lógica 
de construção da solução e/ou na ordem em que as instruções do algoritmo/programa se 
econtram.
Um programa sem erros de sintaxe pode ser executado em um computador, mas 
ele pode não produzir os resultados corretos. Para que um programa funcione como deve, 
é necessário passar as instruções para o computador em uma sequência específica, não 
se deve deixar instruções de fora nem adicionar instruções irrelevantes. Esta sequência, 
ou encadeamento de instruções consiste na lógica de um algoritmo/programa de 
computador. Imagine que alguém seja instruído a fazer um bolo da seguinte forma:
Mexa
Ponha dois ovos
Adicione um galão de gasolina
Asse a 350°C por 45 minutos
Coloque três xícaras de farinha
Ainda que se tenha usado a sintaxe correta da língua portuguesa, as instruções 
estão fora de ordem, faltam algumas instruções e algumas não fazem sentido neste 
contexto. Se seguidas essas instruções, além de não se obter um bolo comestível, pode-
se causar um terrível acidente. Erros de lógica são muito mais difíceis de localizar do que 
Página 17
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
erros de sintaxe; é mais fácil determinar se "ovos" contém um erro ortográfico em uma 
receita do que dizer se há ovos em excesso ou se eles foram postos muito cedo.
Retomando conceitos vistos na Seção 1 deste capítulo, pode-se escrever um 
algoritmo que obtém um número inteiro (entrada de dados), dobra-o (processamento) e 
diz a resposta (saída) usando comandos em português. O resultado poderia ser similar ao 
que é apresentado a seguir:
Obter númeroEntrada.
Computar respostaCalculada como sendo 2 vezes númeroEntrada.
Imprimir respostaCalculada.
Uma outra forma de representar uma sequência de comandos que devem ser 
executados por um computador é através de um fluxograma. Portanto, trata-se de uma 
maneira alternativa de se representar um algoritmo. Um fluxograma é uma representação 
gráfica dos passos lógicos a tomar na resolução de um problema. Um exemplo de 
fluxograma logicamente igual às instruções acima é:
Figura 5. Exemplo da representação de algoritmos por fluxograma
O próximo Capítulo trata da introdução à programação de computadores na 
linguagem C++, ou seja, nele são vistos os rudimentos da linguagem de programação e é 
exercitada a transformação de algoritmos simples em programas equivalentes na 
linguagem C++.
4. Exercícios
1. Os dois componentes principais de qualquer sistema de computador são:
a) entrada e saída
b) dados e programas
c) hardware e software
d) memória e drives de discos
Página 18
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
2. Visual Basic, C++ e Java são todos exemplos de:
a) sistemas operacionais
b) hardwares
c) linguagens de máquina
d) linguagens de programação de computadores
3. As regras de uma linguagem de programação compõem sua(s)
a) sintaxe
b) lógica
c) formatação
d) opções
4. A função mais importante de um compilador ou de um interpretador é
a) criar as regras para uma linguagem de programação
b) traduzir sentenças em inglês para uma linguagem como Java
c) traduzir sentenças em linguagem de programação para linguagem de máquina
d) executar programas em linguagem de máquina para realizar tarefas úteis
5. Qual dessas é uma típica instrução de entrada?
a) obter numeroConta
b) calcular contaVencimento
c) imprimir numeroIdentificacaoCliente
d) total = compraJan + compraFev
6. Escrever um programa em uma linguagem como C++ ou Java é conhecido como 
________ o programa.
a) traduzir
b) codificar
c) compilar
d) interpretar
7. Relacione as colunas para estabelecer a associação adequada entre os termos de 
Página 19
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
cada uma delas
1. Equipamentos de sistemas de computadores a. Compilador
2. Outra palavra para programas b. Sintaxe
3. Regras de uma linguagem de programação c. Lógica
4. Ordem das instruções de um programa d. Hardware
5. Tradutor de uma linguagem de programação e. Software
8. Para pesquisar na Web: sob que condições seria preferível utilizar uma linguagem 
compilada e sob que condições seria preferível utilizar uma linguagem 
interpretada?
Página 20
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
Capítulo 2 – Introdução à Programação de 
Computadores e à Linguagem C++
Conforme visto no Capítulo anterior, uma etapa importante do desenvolvimento de 
aplicativos ou softwares está na conversão de um algoritmo em código-fonte contendo 
instruções para um computador, escritas utilizando linguagens de programação. 
Independente da linguagem na qual o programador escreve, um fator em comum a todas 
elas é que as mesmas terão uma sintaxe a ser seguida. Esta sintaxe consiste em regras 
que regulamentam o uso das palavras e da pontuação. Desta forma, para criar um 
programa computacional, o programador inicialmente precisa escolher uma linguagem de 
programação para que ele possa informar ao computador, através de tal linguagem, o que 
o mesmo deve fazer. Neste material são abordadas a sintaxe e demais características da 
linguagem C++. Esta escolha se deve ao fato de se tratar de uma linguagem que inclui os 
principais conceitos de programação e também por poder ser utilizada como base para o 
aprendizado de várias outras linguagens, como Java, Javascript, PHP, dentre outras, que 
guardam uma série de similaridades com C++, incluindo-se aí suas sintaxes.
Tendo sido escolhida a linguagem de programação, pode-se escrever o código 
referente ao programa que deseja desenvolver a partir do algoritmo obtido para a solução 
do problema abordado. Tal código consiste em um arquivo de texto simples que contém 
várias instruções definidas pela linguagem, de maneira que um conjunto de instruções 
não possa gerar ambiguidades.
Vale destacar aqui que o código-fonte, por se tratar de apenas um arquivo de 
texto escrito em linguagem C++, não é um arquivo passível de execução direta por um 
computador. Desta maneira o código escrito em C++ deve antes ser transformado, por um 
compilador, em um arquivo executável, ou seja, um arquivo binário, descrito em uma 
linguagem chamada de “linguagem de máquina”, de difícil compreensão para um ser 
humano. Destaca-se também que, para se compilar um mesmo código-fonte, podem 
existir diferentes compiladores, desenvolvidos por diferentes fabricantes de software. 
Este caso se aplica à linguagem C++. Dentre os várioscompiladores encontrados no 
Página 21
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
mercado, para as aulas práticas de INF 100 foi decidida a adoção de um compilador 
gratuito, de livre distribuição, para o Sistema Operacional Linux, chamado G++.
Na próxima seção, são introduzidos os elementos básicos para se construir um 
programa simples em C++.
1. O programa “Alo Mundo!”
A maior parte dos programas é feita para interagir com o usuário do computador, ou seja, 
o usuário deve solicitar que o programa faça alguma operação, informar os dados 
necessários para que a operação seja concluída com sucesso e, em seguida, o aguardar 
o resultado gerado pelo programa. Essa interação é realizada através dos dispositivos de 
entrada (teclado, mouse, etc) e saída (monitor, impressora, etc).
Nos programas criados a partir do escopo de estudo deste material, serão 
utilizados apenas recursos da interface de texto do Sistema Operacional. Assim, não será 
abrangido o emprego do mouse como dispositivo de entrada para programas aqui 
tratados. Portanto, apenas os dispositivos de entrada e saída padrões do C++ serão 
utilizados como meios de interação com o usuário do aplicativo. Os dispositivos em 
questão são o teclado, para entrada de dados e o monitor, para saída de dados. Na parte 
final do material também serão utilizados dispositivos de memória secundária para leitura 
e gravação de informações de forma duradoura, sob a forma de arquivos. Portanto, 
entrada e saída de dados também serão realizadas para dispositivos como discos rígidos, 
pendrives e similares. No entanto, apesar de poderem ser vistos como dispositivos de 
entrada e saída, os arquivos não têm a finalidade de promover a interação direta com o 
usuário, como acontece com o teclado e o monitor de vídeo.
Com base nisto, o primeiro programa visto consiste apenas em um aplicativo 
simples, que exibe uma mensagem na tela sem exigir que o usuário informe qualquer 
dado. Para enviar a mensagem para a tela, pode-se utilizar o comando cout, que envia 
uma informação para ser exibida no monitor. Antes de se ilustrar a regra de escrita, ou 
seja, a sintaxe do comando cout, é necessário estabelecer uma convenção, apresentada 
a seguir, para melhor compreensão deste material.
Todo texto dos exemplos de trechos de códigos-fonte, programas e afins, 
compreendido entre os sinais < e >, grafado em itálico, deve ser interpretado, durante a 
Página 22
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
leitura de uma instrução, como algo que deve ser substituído por um texto de escolha do 
programador. O texto que aparece dentro dos referidos sinais tem, como objetivo, 
informar ao leitor que tipo de valor, comando ou informação deve ser escolhida pelo 
programador para a geração de seu código. Por exemplo, a sintaxe para o uso do 
comando cout é apresentada a seguir:
cout << “<Texto a ser exibido em tela>”
Isto significa que <Texto a ser exibido em tela> deve ser substituído, pelo 
programador, durante a escrita de seu código por algo que o mesmo deseja que seja 
apresentado no monitor para o usuário, como ilustra o comando abaixo:
cout << "Bom dia.";
Quando a linha acima for executada pelo computador, o texto escrito entre aspas, 
isto é, Bom dia, será apresentado na tela do monitor para o usuário, sem as aspas, no 
entanto. As aspas, neste caso, têm o papel de delimitar o início e o final da mensagem a 
ser enviada para o usuário4.
Entretanto, para que um programa que faça a mera exibição de uma mensagem 
em tela para o usuário, utilizando o comando cout, tenha seu código-fonte interpretado 
corretamente pelo compilador e a partir dele possa ser gerado um programa executável, é 
importante que o arquivo do programa representado pelo código-fonte obedeça a seguinte 
estrutura geral:
1. Definição das bibliotecas que serão utilizadas pelo programa
2. Início do programa
3. Linhas de código que definem o que o programa deve fazer
4. Fim do programa
A linha 1 da estrutura acima diz respeito ao conceito de bibliotecas. Biblioteca é 
uma coleção de subprogramas que podem ser utilizados durante o desenvolvimento de 
4 Caso a mensagem para o usuário careça do caracter das aspas, o mesmo deverá ser precedido por \. Por exemplo, 
para se exibir ao usuário a mensagem Ele disse “que susto!” antes de dormir, a instrução correspondente em 
C++ seria cout << “Ele disse \”que susto!\” antes de dormir”.
Página 23
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
um software. Elas consistem em um conjunto de trechos de códigos e também dados 
auxiliares, que provêm serviços ao programa que se está desenvolvendo. Por exemplo, 
para que um desenvolvedor não tenha que implementar novamente dentro cada novo 
programa um procedimento que realize a leitura de um conjunto de dados a partir de um 
determinado tipo de arquivo, o mesmo pode criar uma biblioteca contendo o código 
correspondente a tal procedimento e simplesmente referenciar esta biblioteca em novos 
programas, aproveitando, assim uma solução já desenvolvida anteriormente. As 
implicações do reaproveitamento de código por meio de bibliotecas e outros recursos 
similares, como funções podem ser melhor percebidas mais adiante neste material, 
durante o capítulo referente ao conceito de funções em programas de computador.
Portanto, para que não se tenha que codificar operações elementares como a 
leitura de dados a partir do teclado ou a saída em tela, mesmo o programa básico 
apresentado aqui depende da utilização de bibliotecas padrões da linguagem C++, 
distribuídas normalmente juntamente com os compiladores desta linguagem. Dessa 
forma, o código-fonte de um programa que exibe a mensagem Alo Mundo! ao usuário e 
que reflete a estrutura geral apresentada anteriormente é apresentado a seguir.
1. #include <iostream>
2. using namespace std;
3. int main()
4. {
5. cout << "Alo Mundo!";
6. return 0;
7. }
A numeração das linhas empregada no trecho acima tem papel meramente 
didático, não devendo ser consideradas como parte integrante do código, uma vez que 
servem para que o texto possa fazer referências a trechos específicos da codificação de 
um programa. Esta convenção é válida, a partir deste ponto, para todo o restante dos 
exemplos e exercícios apresentados neste material. A seguir, tem-se uma análise 
detalhada do código de programa apresentado acima.
As duas linhas iniciais são referentes à inclusão da biblioteca iostream no código. 
Esta biblioteca deve ser incluída porque é nela que está implementada o comando cout, 
responsável pela impressão da mensagem Alo Mundo! no monitor, realizada na linha 5. 
Cada biblioteca utilizada deve ser inserida separadamente, utilizando um comando 
Página 24
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
#include para cada biblioteca, como no exemplo abaixo:
#include <iostream>
#include <cmath>
#include <iomanip>
As bibliotecas cmath e iomanip, ilustradas aqui, trazem consigo a implementação 
de outros comandos que são melhor explicados em capítulos mais adiante. Quanto à 
segunda linha do programa (using namespace std;), por ora deve-se ater ao fato de que 
a mesma será sempre utilizada quando a biblioteca iostream for incorporada ao código 
fonte e que seu papel consiste em abreviar a sintaxe da escrita das instruções da 
biblioteca.
Em seguida, nas linhas 3 e 4, é apresentado o código de inicialização do 
programa. Por enquanto, não é importante saber o significado preciso de cada termo da 
sintaxe, uma vez que isso será detalhado melhor posteriormente neste material.No 
momento, o mais importante é que o leitor esteja atento ao fato de que o código 
executado pelo computador é o que está compreendido entre as chaves das linhas 5 e 8. 
Toda vez que um computador for executar o programa compilado a partir do código 
gerado por um programador ele começará pela primeira instrução após a chave que 
sucede int main(). A chave de abertura após o trecho citado delimita o início lógico do 
programa.
A linha 6 é a linha responsável por executar o que o programa de exemplo se 
propõe a fazer, ou seja, imprimir a mensagem Alo mundo! na tela do computador. Este 
programa tem efetivamente uma única linha que corresponde diretamente à lógica 
desejada pelo programador. Isto quer dizer que o algoritmo correspondente a este 
programa poderia ser simplesmente:
exibir em tela a mensagem: Alo Mundo!
Ou ainda, em uma notação mais próxima à uma linguagem para programação de 
computadores:
imprimir “Alo Mundo!”
Página 25
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
Os próximos programas apresentados possuem código mais complexo que este, 
de modo que possam refletir algoritmos mais elaborados. Um detalhe importante que 
deve ser observado é que cada linha correspondente a uma instrução para o computador 
deve terminar com um o caracter ; (ponto e vírgula). O ponto e vírgula é o responsável por 
indicar que um comando foi terminado e que o que vem a seguir se refere a outra 
instrução.
Por fim, as linhas 7 e 8 são referentes à finalização do programa. Novamente sem 
discorrer acerca de maiores detalhes, o papel da linha 7 consiste em informar ao 
computador que o programa foi encerrado e enviar uma mensagem ao Sistema 
Operacional de que tal fato ocorreu de forma esperada. O fechamento de chaves 
apresentado na linha 8 é uma convenção sintática da linguagem para coerência com o 
delimitador de abertura encontrado na linha 4.
Para que se possa ilustrar um processo completo de geração de um aplicativo, 
por mais simples que seja, a próxima seção tem como objetivo tratar de aspectos 
relacionados à compilação e execução de programas em C++.
2. Compilação do código-fonte e execução do programa
Para executar o código mostrado na Seção anterior, assim como os demais códigos C++ 
aqui apresentados, é necessário que se digite o código-fonte desejado em um editor de 
texto simples e salve o arquivo com a terminação .cpp. Isto indicará ao Sistema 
Operacional que o arquivo em questão se trata de um código-fonte escrito em C++. Em 
seguida, conforme ilustrado no processo representado na Figura 3, deve-se usar um 
compilador para gerar o arquivo executável e, assim, poder executar o arquivo binário 
resultante e testar o aplicativo. No ambiente encontrado nas aulas práticas da disciplina 
estes passos são executados utilizando-se o editor de texto Kate e o compilador G++.
O editor Kate, além de ser um editor de texto, possui também uma interface para 
utilização de comandos de texto do Sistema Operacional Linux. Dessa forma, após digitar 
o código, poderia-se salvá-lo em um arquivo com terminação .cpp como, por exemplo, 
alomundo.cpp e, posteriormente usar a interface de comandos Linux contida no Kate para 
compilar o código e testar o aplicativo. Para tal, deve-se digitar o comando g++ <nome do 
arquivo cpp> a partir do diretório (pasta) onde o arquivo do código-fonte foi salvo. Por 
Página 26
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
exemplo, o comando de compilação para um arquivo alomundo.cpp, caso do exemplo 
mencionado neste parágrafo, seria:
g++ alomundo.cpp
Este comando verifica se o código contido no arquivo tem algum erro sintático e, 
não se encontrando nenhum erro de sintaxe, é gerado, por padrão, um arquivo executável 
com o nome a.out. O arquivo a.out seria independente do arquivo alomundo.cpp e 
poderia ser executado mesmo que este último não estivesse presente. No entanto, só 
poderia ser executado em computadores que possuíssem hardware e Sistema 
Operacional compatíveis com aqueles do computador onde a.out foi gerado. Para se 
realizer a execução deste aplicativo, basta utilizar o comando a seguir na interface de 
modo texto (chamada console) do Linux, dentro da interface do Kate:
./a.out
Se não tiver sido cometido nenhum erro nas etapas anteriores, após digitar o 
comando acima e apetar a tecla Enter, aparecerá na tela do console o texto Alo Mundo! 
logo abaixo do comando de execução de a.out. A seguir, tem-se um exemplo ilustrando a 
aplicação de vários comandos cout para geração de sequências de texto na tela, seguida 
de sua respectiva saída em tela:
1. #include <iostream>
2. using namespace std;
3.
4. int main()
5. {
6. cout << "Nome: Fulano";
7. cout << "Matrícula: 12345";
8. cout << "INF100";
9. return 0;
10.}
Nome: FulanoMatrícula: 12345INF100
Pode-se notar que o resultado exibido no monitor não é dividido em três linhas, 
como são as instruções contidas entre as linhas 6 e 8. Todos os trechos de texto são 
mostrados em apenas uma linha, ao invés de uma linha para cada comando cout. Isto 
Página 27
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
ocorre porque, na linguagem C++, os espaços em branco (início das linhas 6, 7, 8 e 9), as 
linhas em branco (linha 3) e o uso de cada comando em uma linha diferente não fazem 
diferença no resultado exibido em tela. Em outras palavras, o programa é executado 
como se todos os comandos estivessem na mesma linha. Conforme mencionado no 
Capítulo 1, o computador executa precisamente o que lhe foi instruído e, em momento 
algum lhe é instruído, no código acima, que se faça a troca de linhas durante a exibição 
das mensagens no monitor. Por esta razão, a saída acontece em uma única linha.
A formatação de escrita do código apresentada no exemplo anterior tem objetivo 
de apenas tornar o código mais legível para o leitor ou o programador. Sendo assim, não 
faria diferença alguma para o resultado obtido se o código fosse escrito como mostrado 
abaixo, uma vez que as instruções contidas no programa são rigorosamente as mesmas e 
seguem a mesma ordenação e encadeamento lógico do exemplo anterior:
1. #include <iostream>
2. using namespace std;
3. int main() {
4. cout << "Nome: Fulano";cout <<"Matrícula: 12345";cout<<"INF100";
5. return 0;
6. }
Para se obter um resultado que corresponda à saída em múltiplas linhas, ou seja, 
fazer que a cada comando cout corresponda uma linha diferente da saída em tela, é 
necessário informar ao computador que se deseja efetuar a troca de linhas. Isto pode ser 
feito dentro do próprio texto delimitado pelas aspas através da sinalização \n. Assim, 
bastaria modificar o programa original da seguinte maneira:
1. #include <iostream>
2. using namespace std;
3.
4. int main()
5. {
6. cout << "Nome: Fulano\n";
7. cout << "Matrícula: 12345\n";
8. cout << "INF100\n";
9. return 0;
10.}
Note que no final de cada texto a ser impresso existe o caractere especial \n para 
indicar que, a partir daquele ponto, todo texto que for impresso deve ser exibido em uma 
Página 28
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
nova linha. O mesmo resultado poderia ser obtido por meio da união dos textos de todos 
os comandos cout, com o emprego da sinalização de quebra de linha, como mostrado 
abaixo:
cout << "Nome: Fulano\nMatrícula: 12345\nINF100\n";
Portanto, deve-se ter atenção para que não se confunda a escrita do código com 
a formatação de textos a serem exibidos em tela. A próxima seção trata de outros 
aspectos que visam a melhor compreensão do código por parte do programador, mas que 
não faz diferença alguma para a compilação e execução de aplicativos.3. Comentários: objetivo e como usar
Um comentário é um trecho do código-fonte que será ignorado sumariamente pelo 
compilador. Ele permite que o programador adicione texto ao programa, com objetivo 
único de facilitar o entendimento do programa por parte de outros programadores, ou até 
de si próprio em momentos futuros. Os comentários são utilizados para anotar 
observações a respeitos de trechos de código, documentar considerações e 
padronizações acerca de algo que foi levantado no estudo do problema e qualquer outra 
finalidade que possa dar suporte à leitura e compreensão do código lido.
Em C++, existem dois tipos de comentários: os comentários de única linha e os 
comentários de bloco. Um comentário de única linha é iniciado pelos caracteres // e 
terminado com a troca de linha do próprio código. Um comentário de bloco é iniciado 
pelos caracteres /* e pode se estender por várias linhas até que se encontre os 
caracteres */ , indicando o fim do comentário.
A primeira situação indica ao compilador que tudo o que estiver contido naquela 
linha, a partir da sequência //, deve ser descartado, desconsiderado durante a 
compilação, é um mero, como a própria denominação já indica, comentário. A segunda 
situação indica que o compilador deve ignorar tudo o que se seguir no código até que 
encontre a sequência */. O código abaixo mostra um exemplo contendo os dois tipos de 
comentários.
1. /* Este é um programa simples usado apenas para exemplificar
Página 29
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
2. os tipos de comentários existentes em C++.
3. Programador: João da Silva
4. Data: 18/01/2011
5. */
6. #include <iostream>
7. using namespace std;
8. int main() {
9.
10. // imprimir algumas linhas de exemplo
11. cout<<"linha 1\n";
12. cout<<"linha 2\n";
13. cout<<"linha 3\nlinha 4"; // o \n divide a linha 3 e linha 4
14. cout<< “\nlinha 5\n” /* isto não deve ser exibido */ << “linha 5”;
15.
16. return 0; // finaliza o programa
17. }
Note que os comentários são utilizados no exemplo para descrever o papel de 
trechos, dados a respeito do próprio programa ou ocultar do compilador sequências de 
caracteres. Podem ser utilizados em diversos outros contextos, como eliminar 
temporariamente um trecho inteiro de código para se fazer testes, dentre outras 
possibilidades. O uso de comentários e de uma boa organização ou padronização para a 
escrita de códigos-fonte consistem em boas práticas de programação, aumentando a 
legibilidade e, consequentemente, a interpretabilidade do código em análises posteriores, 
por parte do programador ou de terceiros. A próxima seção trata de um elemento central 
para a construção de programas mais elaborados e que tem uma relação direta com a 
utilização da memória do computador, o conceito de variável.
4. Variáveis
4.1 Declaração de variáveis
Os códigos apresentados seções anteriores apenas exibem textos estáticos na tela. Para 
o desenvolvimento de programas um pouco mais complexos e úteis é importante, 
primeiramente, introduzir o conceito de variáveis.
Para se armazenar dados na memória do computador é necessário alocar 
(reservar) um espaço na memória que seja suficiente para armazenar tais dados. Além 
disso, também é necessário definir uma forma de se acessar o espaço alocado para este 
armazenamento. Para isso, é utilizado o conceito de váriável, que é uma abstração de um 
Página 30
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
espaço na memória principal do computador. A cada variável é associado um 
identificador (nome) que permite o acesso às informações armazenadas na área da 
memória correspondente à variável em questão.
O primeiro passo para se definir uma variável é saber qual tipo de dado ela 
deverá armazenar. Isso é importante porque, como uma variável representa um espaço 
na memória do computador, é necessário saber a quantidade de memória que deverá ser 
alocada a essa variável e também o formato (padrão) de armazenamento que os bits da 
variável deve seguir. Por exemplo, um número inteiro normalmente ocupa menos espaço 
do que um número real e mais espaço que um caractere simples. Além disso, parte dos 
bits que são destinados ao armazenamento de um número real tem o papel de armazenar 
informações sobre suas casas decimais, necessidade que não existe para números 
inteiro. Assim, para armazenar um número real, o computador deve saber identificar quais 
bits irão compor a parte inteira e quais irão compor a parte fracionária. No caso de um 
número inteiro, todos (quase todos, na realidade) os bits serão destinado ao 
armazenamento do número, sem separação para a parte decimal. Para representar os 
tipos de dados, a linguagem C++ disponibiliza várias palavras-chave, cada uma referente 
a um tipo. A Tabela 2, a seguir, apresenta os principais tipos de dados da linguagem C++:
Tipo Descrição Exemplos de valores
int Números inteiros 12, 0, 1993, -123, -9
float Números de ponto flutuante 
(representação computacional de 
números reais)
12.0, 3.141592, -23.443, 
2.0
double Números de ponto flutuante de precisão 
dupla
12.0, 3.141592, -23.443, 
2.0
char Caractere (armazena UM caractere) 'a', 'b', '-', '+', ' ', '1', '4'
bool Valor lógico (booleano) true, false
Tabela 2. Tipos de Dados Básicos em C++
Um aspecto importante, inerente ao tipo de dados com o qual se deseja trabalhar 
e consequência da limitação de espaço em memória disponível para cada variável, é a 
limitação dos valores os quais uma variável pode armazenar. Por exemplo, uma variável 
inteira (tipo int) tem espaço de armazenamento de 2 bytes, isto é, dispõe de 16 bits para 
Página 31
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
representação de números inteiros. Além disso, inteiros podem assumir valores positivos 
ou negativos. Assumindo-se que um dos bits dessa sequência de 16 bits é destinado ao 
armazenamento do sinal do número (positivo ou negativo), a faixa de valores 
representável em uma variável do tipo int está limitada a números representáveis em 15 
bits, isto é valores que vão de 0 a 215-1 (que é o número decimal 32.767). A seguir, a 
Tabela 3 ilustra os valores representáveis no principais tipos de dados numéricos básicos 
suportados pela linguagem C++. Vale destacar que os números representados nestes 
tipos numéricos básicos da linguagem são suficientes para um grande número de 
aplicações práticas.
Tipo Tamanho em 
Memória
Representatividade
int 2 bytes -32.768 a 32.767
unsigned int 2 bytes 0 a 65.535
long int 4 bytes -2.147.483.648 a 2.147.483.647
unsigned long int 4 bytes 0 a 4.294.967.295
float 4 bytes ± (10-38 a 1038)
double 8 bytes ± (10-308 a 10308)
Tabela 3. Valores representáveis em cada tipo de dado em C++
Uma vez sabido, ou identificado, o tipo de dado que será armazenado, é 
necessário, então, definir um identificador, isto é, um nome, para a variável que será 
declarada. Pelo fato de uma variável se tratar de uma abstração para um espaço de 
memória do computador, o identificador da mesma é uma maneira mnemônica de se ter 
acesso àquele espaço da memória.
O identificador da variável, de preferência, deve deixar claro qual é a informação 
que a variável tem o papel de armazenar. Por exemplo, se uma variável vai ser usada 
para armazenar o resultado de uma operação qualquer realizada pelo programa, 
podemos colocar o nome resultado na variável. Assim, para declarar esta variável, se o 
resultado da operação é um número inteiro, é necessário apenas escrever a seguinte 
linha no código do programa:
Página 32
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhãesint resultado;
Com esse comando, é reservado um espaço na memória suficiente para 
armazenar um número inteiro e esse espaço na memória pode ser acessado utilizando o 
identificador resultado. Por exemplo, as duas linhas de código abaixo realizam, 
respectivamente, uma operação para gravação de um valor na variável, gravando o valor 
5 na mesma, e outra operação para a leitura do valor da variável (o valor da variável é lido 
da memória e utilizado no comando cout). Ao comando de gravação de um valor em uma 
variável, pelo método mostrado a seguir, dá-se o nome de atribuição.
resultado = 5;
cout << resultado;
Note que, ao utilizar uma variável no comando cout, não são utilizadas aspas. 
Isso acontece porque as aspas são utilizadas para indicar que a informação delimitada 
por elas se trata de um texto. Dessa forma, ao utilizar o nome da variável no cout, o valor 
dessa variável será lido a partir da memória e em seguida será impresso na tela. Note que 
o comando
cout << "resultado";
exibe o texto na tela “resultado” (sem aspas) e não o valor da variável resultado, como 
acontece no exemplo anterior. As saídas em tela correspondentes aos dois trechos de 
código ilustrados acima são, respectivamente:
5
e
resultado
Outra característica importante do comando cout é que é possível concatenar 
vários operadores << de modo a imprimir mais de um texto ou mais de uma variável. Veja 
o exemplo a seguir:
int resultado;
resultado = 5;
cout << "O resultado é igual a " << resultado << ".";
Página 33
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
O código acima imprime a seguinte linha de texto na tela:
O resultado é igual a 5.
Também é possível, em apenas uma linha de código, declarar e inicializar a 
variável com um valor, combinando os comandos de declaração e atribuição. É possível, 
ainda, declarar várias variáveis do mesmo tipo em um único comando utilizando uma 
vírgula para separar cada variável. Os exemplos abaixo exibem algumas formas válidas 
de se declarar e/ou inicializar variáveis:
int a = 3; // a é uma variável inteira e vale 3
int b, c; // b e c são inteiros sem valores definidos
float x = 1, y = 2.5; // x e y são valores reais, com os valores 1,0 e 2,5, respectivamente
int i, j, k = 3; // i e j não têm valores definidos e k = 3
A seguir são apresentados exemplos de declaração e inicialização de variáveis do 
tipo char. Essas variáveis são utilizadas para armazenar um caractere (note que os 
caracteres são escritos entre apóstrofos).
char p = 'a'; // armazena o caractere 'a' na variável p, p = 'a'
char q = '+'; // armazena '+' em q , q = '+'
char x = '\n'; // armazena o caractere '\n' em x (caractere de “quebra de linha”) x= '\n'
char r = 'p'; // armazena 'p' em r , r = 'p'
char s = p; // armazena o valor da variável p em s, s = 'a'
Vale mencionar que os identificadores utilizados para nomear as variáveis em C+
+ devem ser formados utilizando determinadas regras de nomeação, que fazem parte da 
sintaxe da linguagem. Tais regras são apresentadas na seção seguinte.
4.2 Regras para nomeação de variáveis
O nome de uma variável não pode gerar ambiguidades. Desta maneira, duas variáveis 
não devem possuir o mesmo identificador. Isto quer dizer que não se pode criar uma 
variável de nome resultado, para armazenar um valor inteiro e outra, também de nome 
resultado para armazenar um valor real. O programa não saberia diferencia-las durante a 
execução e não teria como distinguir qual delas seria utilizada em dado contexto. 
Página 34
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
Entretanto, a linguagem C++ faz diferenciação de caracteres maiúsculos e minúsculos, 
interpretando-os como símbolos diferentes. Isto quer dizer que o conjunto de declarações 
de variáveis a seguir é válido, de acordo com a sintaxe de C++:
int valor; // valor destina-se a armazenar números inteiros
int Valor; // Valor armazenará inteiros e é diferente de valor
float VALOR; // VALOR armazenará valores de ponto flutuante
Além disso, um identificador não pode ser igual a alguma palavra reservada da 
linguagem C++, por exemplo: int, float, char, return, main, etc. As palavras reservadas 
são palavras que têm um significado especial na linguagem e seu uso é reservado aos 
comandos e estruturas da mesma. Declarar uma variável com estes nomes geraria uma 
ambiguidade que “confundiria” o compilador.
Vale mencionar, entretanto, que, em algumas situações especiais, duas variáveis 
podem possuir o mesmo identificador. Tais situações serão definidas no capítulo relativo 
ao conceito de função, deste material. Por ora, a regra da não duplicidade de nomes para 
variáveis é válida em todas as situações.
Os nomes das variáveis podem ser formados utilizando letras maiúsculas ou 
minúsculas (de A a Z, sem acentos), números e o caractere underline ( _ ). Porém, o 
primeiro caractere deve ser uma letra ou o underline, ou seja, o primeiro caractere não ser 
um número.
O padrão C++ atual especifica que nomes de até 31 caracteres devem ser 
aceitos. Apesar da padronização, alguns compiladores podem aceitar nomes com mais 31 
caracteres. Porém, isso não pode ser considerado uma regra e, portanto, é importante 
não utilizar identificadores muito grandes, mesmo se o compilador que está sendo 
utilizado admitir este emprego.
A partir da próxima seção, é vista a utilização de variáveis em contextos um pouco 
mais elaborados e de maior utilidade prática.
5. Expressões aritméticas
Para a realização de cálculos, a linguagem C++ permite o uso de expressões aritméticas 
utilizando determinados operadores. Os principais operadores utilizados na aritmética da 
linguagem são ilustrados na Tabela 4.
Página 35
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
Operador Nome do 
operador
Significado/objetivo
( ) Parênteses Definir precedência (prioridade) entre subexpressões
+ Adição Adição aritmética
- Subtração Subtração aritmética
* Multiplicação Multiplicação aritmética
/ Divisão
Divisão aritmética. O tipo de resultado da 
divisão dependerá dos tipos dos valores ou 
variáveis a serem operados.
% Módulo Resto da divisão. Resulta em um valor inteiro.
= Atribuição de valor
Atribui um valor a uma variável. O valor pode 
ser constante ou obtido da leitura de outra 
variável. Corresponde a gravar um valor na 
memória do computador, no espaço 
identificado pelo nome da variável.
Tabela 4. Operadores aritméticos em C++
O operador de atribuição é utilizado para atribuir (ou armazenar) o resultado de 
uma expressão em uma variável. Por exemplo:
1. int resultado;
2. resultado = 2+6;
3. int x = 2*resultado;
4. float pi = 3.14159;
5. float y = (x+3)*x;
6. y = x+y;
7. x = y = 0;
Na linha 2, a expressão 2+6 é executada e a resposta (8) é armazenada na 
variável resultado que é declarada na linha 1. A linha 3 traz um exemplo mostrando uma 
variável que, em apenas uma linha de código, é declarada e inicializada com o resultado 
da expressão anterior. O terceiro exemplo, na linha 4, exibe a criação de uma variável que 
armazena um valor real e a atribuição de um valor inicial5. O quarto exemplo, na linha 5, 
ilustra o uso de parênteses para que uma operação de adição seja executada antes da 
5 Note que os números reais, em geral, são representados utilizando uma parte inteira separada de uma parte 
fracionária por um ponto, e não por uma vírgula. 
Página 36
INF 100 – Introdução à Programação I – Profs. Marcos Ribeiro, Vitor Souza e Salles Magalhães
operação multiplicação6. O quinto exemplo (linha 6) apresenta uma expressão onde a 
variável que armazena o resultado anterior (y) também é utilizada no cálculo, ou seja, 
primeiro, o computador irá realizar a soma (x+y) e, por fim, o valor obtido na soma será 
atribuído à variável y. Isto significa