fundamentos programacao

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

1
CST em Sistemas para Internet
CST em Análise e Desenvolvimento de Sistemas
NET100 – Fundamentos de Programação
www.upf.br
Prof. Dr. Rafael Rieder
rieder@upf.br
2012/ 01
Introdução à Linguagem C/C++
www.upf.br
Introdução à Linguagem C/C++
• Dennis M. Ritchie e Ken Thompson,
laboratório Bell em 1972
• Evolução da linguagem B de Thompson
l i d li BCPL
HISTÓRICO
www.upf.br
que evoluiu da linguagem BCPL
• A linguagem C++ é baseada na
linguagem C
HISTÓRICO
• C++ representa uma evolução e
refinamento de algumas das melhores
características das linguagens anteriores
www.upf.br
• A linguagem C++ foi criada em 1980 por
Bjarne Stroustrup do laboratório Bell
CARACTERÍSTICAS
• Não é um ambiente de 
programação
• Não é uma linguagem visual
www.upf.br
• Linguagem de nível médio
– Combina elementos das linguagens de
alto nível com as funcionalidades da
linguagem assembly
– Relativamente simples
– Programação estruturada e modular
CARACTERÍSTICAS
• Híbrida (procedural e OO)
• Portabilidade
– Programas em C/C++ podem ser
www.upf.br
compilados e executados sem
alterações em diferentes plataformas
• Eficiência e economia
– Programas são executados em
menos tempo e ocupam pouco
espaço de armazenamento
2
CARACTERÍSTICAS
• Identificadores (variáveis, rótulos, 
funções) e comandos são 
Case Sensitive
V i d d d ft
www.upf.br
• Variedade de softwares para a
linguagem C++
• Coleção de funções e bibliotecas
padronizadas nas implementações
da linguagem C++
ETAPAS
www.upf.br
LINGUAGEM
• Uma linguagem de programação
é o elo entre a linguagem que os
seres humanos entendem e as
www.upf.br
instruções que uma máquina
deve executar para realizar uma
determinada ação.
COMPILADOR x INTERPRETADOR
Um programa é a maneira de se comunicar
com um computador e a única linguagem
que o computador entende é a linguagem de
máquina. Por isso todos os programas que
se comunicam com o computador devem
www.upf.br
se comunicam com o computador devem
estar em linguagem de máquina
A forma como os programas são traduzidos
para a linguagem de máquina é classificada
em duas categorias: interpretados e
compilados
INTERPRETADORES
• Lê a primeira instrução do programa, faz a
consistência de sua sintaxe e, se não
houver erro, converte para linguagem de
máquina, para depois executar
S ó i i t ã ti d
www.upf.br
• Segue para a próxima instrução repetindo o
processo até a execução da última
instrução
• O interpretador precisa estar presente em
as execuções do programa. Portanto, o
trabalho de verificação de sintaxe e
tradução é repetitivo
COMPILADORES
• O compilador lê todas as instruções e faz
a consistência da sintaxe. Se não houver
erro, converte para linguagem de
máquina gerando um arquivo com o
www.upf.br
sufixo .OBJ com as instruções traduzidas
• Na sequência, são agregadas ao arquivo
as rotinas em linguagem de máquina que
lhe permitirão a execução. Isto é feito
pelo linkeditor que, além de juntar as
rotinas, cria o produto final ou arquivo
executável
3
COMPARATIVOS
• Velocidade de execução do programa
compilado chega a ser 20 vezes mais
rápida do que o programa interpretado
• O programa compilado e linkeditado
pode ser executado diretamente sobre o
www.upf.br
pode ser executado diretamente sobre o
sistema operacional, não necessitando
de nenhum outro software
• Programas .EXE não podem ser
alterados, o que protege o código fonte
INTRODUÇÃO
• “Tudo o que há dentro de um
computador, além das funções que ele
realiza, foi criado pelo homem. Pode,
portanto, ser explicado e entendido.”
www.upf.br
p , p
• “A única forma de aprender uma
linguagem de programação ou uma
nova linguagem de programação é
escrever programas nesta linguagem.”
INTRODUÇÃO
• Não existe receita pronta
• Programar é praticar. Envolve
dedicação, persistência, erros,
acertos. O mais importante é
www.upf.br
acertos. O mais importante é
sempre tentar, nunca desistir!
• Conhecimento dos comandos da
linguagem
• Só se aprende a programar
programando!!!!
PRIMEIRO EXEMPLO
#include<iostream>
using namespace std;
main ()
{
www.upf.br
{
cout << "Meu primeiro programa" << endl;
cout << "Pressione ENTER para continuar";
cin.sync();
cin.get();
} 
PRIMEIRO EXEMPLO
• Resultado da execução do programa
www.upf.br
PRIMEIRO EXEMPLO
#include<iostream> // adiciona a biblioteca C++ de funções de entrada/saída
using namespace std; // declara como global o uso do ambiente de nome "std"
// função principal (primeira função a ser executada)
main()
{ // delimitador inicial de bloco
/* cout e endl são objetos/comandos da biblioteca "iostream": cout imprime uma
íd d t t l ( t d d
www.upf.br
saída de caracteres na tela (neste caso, duas mensagens passadas como
argumento entre aspas); já endl realiza uma "quebra" de linha. */
cout << "Meu primeiro programa" << endl;
cout << "Pressione ENTER para continuar";
/* cin é um objeto/comando biblioteca "iostream". Seus complementos (métodos) 
sync e get fazem o programa aguardar o pressionamento da tecla ENTER */
cin.sync();
cin.get();
} // delimitador final de bloco
4
COMENTÁRIOS
• Podem aparecer em qualquer lugar do programa
e são desconsiderados pelo compilador. A
linguagem C/C++ aceita os seguintes tipos de
comentários:
www.upf.br
/* comentário de bloco */
// comentário de linha
• Não é permitido utilizar um comentário dentro do
outro
COMPILADORES C++
• Diferentes compiladores C++ estão disponíveis
em ferramentas de desenvolvimento de
programa, também conhecidas como “Ambientes
de Desenvolvimento Integrado” ou IDE (do inglês
Integrated Devolopment Environment)
www.upf.br
• Os compiladores permitem a geração de códigos
executáveis dos programas desenvolvidos em
linguagem de programação C/C++
• Exemplos de compiladores: C++ Builder, G++,
MinGW, Microsoft Visual C++, Xcode
FERRAMENTAS
• Os ambientes de desenvolvimento facilitam e
agilizam o processo de desenvolvimento de
programas, pois são compostos por um editor,
depurador, compilador e ainda permitem a
execução do arquivo final
www.upf.br
• Existem vários softwares com esta finalidade,
entre eles: Microsoft Visual C++, Borland C++
Builder, Code::Blocks, Dev-C++, Eclipse, etc...
Code::Blocks
www.upf.br
Code::Blocks
• Para desenvolver nossos programas, durante
nossas aulas, utilizaremos o Code::Blocks
(http://www.codeblocks.org/), por ser de fácil
instalação, não necessitar de muitos recursos
de hardware, ser open source e disponibilizar
as ferramentas necessárias
www.upf.br
as ferramentas necessárias
• Download (importante: baixar o arquivo que tem 
o compilador MingW)
• http://sourceforge.net/projects/codeblocks/
files/Binaries/10.05/Windows/codeblocks-
10.05mingw-setup.exe/download
Code::Blocks
• Principais comandos utilizados no Code::Blocks
– Ctrl+S = Salvar
– Ctrl+F9 = Compilar
Ctrl+F10 = Executar
www.upf.br
– Ctrl+F10 = Executar
– F9 = Compilar e Executar
– F8 = Debug
– F5 = Criar Breakpoint (pontos de parada)
5
PRIMEIROS COMANDOS
• Principais comandos ou funções usadas 
para entrada e saída de informação em 
programas C/C++
www.upf.br
• Exibir algo na tela (saída) – cout:
– cout << "mensagem" << identificador;
• Ex: cout << "Valor da variável [X]" << x;
• Comando e caracteres especiais 
usados com cout
– Comando de quebra de linha: endl
PRIMEIROS COMANDOS
www.upf.br
– Impressão de aspas: \"
– Impressão de contrabarra: \\
– Exemplo:
• cout << "Imprime \"aspas\", contrabarra \\, e 
quebra de linha" << endl;
PRIMEIROS COMANDOS
• Outros caracteres especiais usados 
com cout
\n – nova linha
www.upf.br
\r – retorno do cursor
\t – tabulação
\b – retrocesso
PRIMEIROS COMANDOS
• Receber dados do usuário (entrada) – cin:
– cin >> argumento;
• Ex.: cin >> num;
• Neste caso, "num" é o nome de um
www.upf.br
identificador que armazenará o valor digitado
• Ao final do uso de um ou mais comandos cin, é
recomendado usar o comando cin.clear();
para limpar o buffer do teclado
• Para aguardar o pressionamento de uma tecla,
pode-se usar a combinação de comandos
cin.sync(); e cin.get();
IDENTIFICADORES
• São nomes usados para se fazer referência a
variáveis, funções, rótulos e vários outros
objetos definidos pelo usuário
• Deve iniciar por uma letra ou um sublinhado
www.upf.br
p
• Somente os 32 primeiros caracteres de um
identificador são significativos
• São case sensitive, ou seja, as letras maiúsculas
diferem das minúsculas
VARIÁVEIS
• Variáveis são objetos situados na memória 
que representam valores ou expressões
• Cada variável deve ser declarada antes de 
ser utilizada
• A declaração de uma variável especifica o
www.upf.br
• A declaração de uma variável especifica o 
tipo de dado a ser armazenado
• Exemplos:
• int numero; // armazena um valor inteiro (51)
• double peso; // armazena um valor decimal (9.842)
6
TIPOS DE DADOS
• Toda variável deve ser declarada e, ao ser
declarada, deve-se atribuir um tipo. O tipo
determina como os valores de dados serão
representados, o que podem armazenar, e que
tipos de operações podem ser executadas com
estas variáveis Os principais tipos aceitos pela
www.upf.br
estas variáveis. Os principais tipos aceitos pela
linguagem são:
– char = caractere (um único caractere)
– int = números inteiros
– float = número em ponto flutuante em precisão simples
– double = número em ponto flutuante em dupla precisão
– bool = valores lógicos (true / false)
CONSTANTES
• Valores fixos, os quais permanecem 
sem alteração durante toda a vida do 
programa
www.upf.br
• Exemplos:
#define PI 3.14159265
const float teste = 12.5;
OPERADORES
• Atribuição
– Sinal de igual =
• Aritméticos
– Multiplicação *
www.upf.br
– Divisão /
– Adição +
– Subtração –
– Resto da divisão inteira %
OPERADORES
• Relacionais
– Maior que >
– Maior ou igual a >=
– Menor que <
– Menor ou igual a <=
www.upf.br
g
– Igual ==
– Não igual !=
• Lógicos
– E (and) &&
– Ou (or) ||
– Negação (not) !
OPERADORES
• Incremento
– Incrementa antes ++variável
– Incrementa após variável++
www.upf.br
• Decremento
– Decrementa antes --variável
– Decrementa após variável--
• Diferenças entre o uso de pré- e pós-incremento
main()
{
int c;
c = 5;
cout << c << endl; // imprime 5
cout << c++ << endl; // imprime 5 e pós-incrementa
OPERADORES
www.upf.br
cout << c << endl; // imprime 6
c = 5;
cout << c << endl; // imprime 5
cout << ++c << endl; // pré-incrementa e imprime 6
cout << c << endl; // imprime 6
cin.sync();
cin.get();
}
• Decrementos: aplica-se a mesma ideia!
7
OPERADORES
• Notação abreviada
– Combina o operador de atribuição = com 
um operador aritmético
Expressão abreviada Expressão equivalente
www.upf.br
contagem += 2 contagem = contagem + 2
total –= 2 total = total – 2
bonus *=2 bonus = bonus * 2
fator /= tempo fator = fator / tempo
troco %= 100 troco = troco % 100
quant *= cont1 + cont2 quant = quant * (cont1 + cont2)
REGRAS BÁSICAS
• Usar SEMPRE comentários em seu código fonte
• Usar INDENTAÇÃO de seus fontes (padrão
mínimo: 2 espaços). O padrão de indentação
deve ser o mesmo em todo o programa, e deve
www.upf.br
p g ,
ser inserido na digitação do programa e não
após ele já estar pronto
• Nunca tente redefinir palavras reservadas de
uma linguagem
REGRAS BÁSICAS
• Em expressões matemáticas, não existem { }
(Chaves), [ ] (Colchetes). Todos os níveis de
precedência devem ser construídos com ()
(Parênteses)
www.upf.br
• Todas as regras matemáticas são respeitadas
pelo computador
• O 0 (zero) é totalmente diferente de nada (NULL)
→ 0 <> Nada
REGRAS BÁSICAS
• Devemos, sempre que possível, aproveitar ao
máximo as linhas de código e as variáveis já
existentes
• Uma linha de comando termina sempre com um
www.upf.br
• Uma linha de comando termina sempre com um
ponto-e-vírgula (;)
• Podemos ter dois comandos em uma mesma
linha, desde que os mesmos estejam separados
por ponto-e-vírgula (;)
REGRAS BÁSICAS
• Recomenda-se na codificação dos algoritmos no
computador o uso de letras minúsculas
(facilidade de leitura), reservando as maiúsculas
para algum tipo de destaque ou para constantes
www.upf.br
• Como regra, nomes de identificadores (nomes
de variáveis, nomes de funções) válidos não
devem possuir espaços em branco.
Recomenda-se o uso de letras ao início dos
identificadores
REGRAS BÁSICAS
• Os nomes de quaisquer identificadores
(variáveis, nome de funções) não podem, em
hipótese nenhuma, serem repetidos
• Após o término de cada área do algoritmo ou
www.upf.br
p g
após cada função, é aconselhável deixar uma
linha em branco para uma melhor organização
• O computador detecta somente erros de
sintaxe, nunca erros de lógica
8
Funções Matemáticas
www.upf.br
Funções Matemáticas
BIBLIOTECA CMATH
• A biblioteca cmath é usada para execução
de várias operações matemáticas, entre as
principais destaca-se:
pow: calcula a potência de um número
www.upf.br
– pow: calcula a potência de um número
de ponto flutuante elevado a outro
– Sintaxe: pow(x,y);
– Ex: pow(3.0, 2.0);→ 32→ retorna 9
BIBLIOTECA CMATH
• sqrt: calcula a raiz quadrada de um
determinado número de ponto flutuante
– Sintaxe: sqrt(x);
– Ex: sqrt(4.0);→ retorna 2
www.upf.br
• fabs: obtém o valor absoluto de um número
de ponto flutuante, sem considerar o sinal
– Sintaxe: fabs(x);
– Ex: fabs(–8.0); → retorna 8
BIBLIOTECA CMATH
• ceil: arredonda um número de ponto
flutuante para cima
– Sintaxe: ceil(x);
– Ex: ceil(3.6)→ retorna 4
www.upf.br
• floor: arredonda um número de ponto
flutuante para baixo
– Sintaxe: floor(x)
– X deve ser de ponto flutuante
– Ex: floor(5.7)→ retorna 5
BIBLIOTECA CMATH
• log: computa o logaritmo natural (ln)
– Sintaxe: log(num);
– Ex: log(5.5)→ retorna 1.704748
www.upf.br
• log10: computa o logaritmo de base 10
– Sintaxe: log10(num)
– Ex: log10(1000.0)→ retorna 3.0
Manipulação de Caracteres
www.upf.br
Manipulação de Caracteres
9
STRINGS
• Para armazenar uma cadeia de caracteres (uma
palavra, por exemplo), é preciso utilizar uma
biblioteca de manipulação de caracteres e um
tipo especial de dado (string). Exemplo:
#include<iostream>
#i l d t i // bibli t d i l ã d t
www.upf.br
#include<string> // biblioteca de manipulação de caracteres
using namespace std;
main ()
{
string nome("Fulano"); // tipo de dado string
cout << "Programa do " << nome << endl;
cin.sync();
cin.get();
} 
STRINGS
• Para leitura de uma cadeia de caracteres, é
aconselhável o uso da função getline. Exemplo:
#include<iostream>
#include<string>
using namespace std;
main ()
www.upf.br
()
{
string nome;
cout << "Entre com seu nome completo: ";
getline(cin, nome); // comando para leitura de strings
cout << "Obrigado, " << nome;
cin.clear();
cin.sync();
cin.get();
} 
STRINGS
• Cópia de strings
– Para copiar o conteúdo de uma string, basta 
utilizar o operador de atribuição "="
– Sintaxe: str = "string";
www.upf.br
– Exemplo:
string dst, src("Caracteres");
dst = src;
cout << dst; // imprime Caracteres
STRINGS
• Método assign
– Determina o conteúdo de uma string, ou
copia o conteúdo de uma para outra
– Sintaxe: str1.assign(str2);
www.upf.br
S ta e st ass g (st );
– Exemplo:
string str("Fulano");
str.assign("Beltrano");
cout << str << endl; // Beltrano
STRINGS
• Concatenação de strings
– É possível concatenar duas strings usando
o operador "+"
– Exemplo:
www.upf.br
e p o
string str("Fulano");
str = str + " de Tal";
cout << str << endl; // Fulano de Tal
STRINGS
• Método append
– Permite concatenar duas strings
agrupando o resultado no primeiro
argumento
www.upf.br
– Sintaxe: str1.append(str2);
– Exemplo:
string str("Fulano");
str.append(" de Tal");
cout << str << endl; // Fulano de Tal
10
STRINGS
• Método length
– Verifica o tamanho de uma string,
retornando um valor inteiro
– Sintaxe: str.length();
www.upf.br
Sintaxe: str.length();
– Exemplo:
int tam;
string str("Texto");
tam = str.length();
STRINGS
• Método compare
– Compara duas strings. Se forem
exatamente iguais, devolve 0
– Sintaxe: str1.compare(str2);
www.upf.br
– Exemplo:
string str1("Azul"), str2("Verde");
if(str1.compare(str2) != 0)
cout << "Cores diferentes";
else
cout << "Cores iguais";
STRINGS
• Métodos clear e empty
– Respectivamente, limpa o conteúdo da
string, e verifica se a mesma está vazia
– Sintaxes:
www.upf.br
– str.clear() str.empty()
– Exemplo:
string str("Vermelho");
str.clear();
if(str.empty())
cout << "Vazia";
Comandos Condicionais
www.upf.br
Comandos Condicionais
TESTE CONDICIONAL
• Comando condicional simples:
– O comando condicional simples (Se ...
[Senão]), tem por finalidade avaliar uma
condição e decidir se os comandos serão ou
não executados SE o resultado da condição
www.upf.br
não executados. SE o resultado da condição
for "TRUE" (verdadeiro), as instruções
referentes ao SE serão executadas, caso
contrário, quando o resultado da condição for
"FALSE" (falso), os comandos referentes ao
comando ("IF") não serão executados
TESTE CONDICIONAL
• Exemplo em algoritmo
se (condição)
comando; // Início <comandos;> Fim
www.upf.br
senão
comando; // Início <comandos;> Fim
11
TESTE CONDICIONAL
• Exemplo em C/C++
if (condição)
comando; // { <comandos;> };
www.upf.br
{ }
else
comando; // { <comandos;> };
TESTE CONDICIONAL
• O comando permite colocar instruções que
somente serão executados se a condição for falsa
("FALSE"). Estes comandos deverão ser escritos
após o comando de SENÃO ("ELSE").
www.upf.br
• Em nenhuma hipótese comandos relativos ao SE e
ao SENÃO serão executados juntos. Um
automaticamente exclui o outro, ou seja, caso a
linha de execução siga pelo "se", ela não poderá
passar pelo "senão" e caso siga pelo "senão" ela
não poderá passar pelo "se".
TESTE CONDICIONAL
• Os comandos IF (se) ou ELSE (senão)
executam uma instrução ou um bloco de
instruções. Sendo mais de um comando, a
área é considerada como um bloco, e a
apresentação dos delimitadores de início
www.upf.br
p ç
"{" e fim "}" de bloco são obrigatórios.
• As condições avaliadas no teste
condicional podem ser simples (uma única
condição) ou composta.
TESTE CONDICIONAL
• Condição simples:
– Existe somente um teste a ser feito.
Exemplo
if (media >= 5 0)
www.upf.br
if (media >= 5.0)
cout << "Aluno aprovado";
else
cout << "Aluno reprovado";
TESTE CONDICIONAL
• Condição composta:
– Possui mais que um teste a ser feito ou
condição a ser verificada
Exemplo
if ((media >= 5 0) && (frequencia >= 0 75))
www.upf.br
if ((media 5.0) && (frequencia 0.75))
cout << "Aluno aprovado";
else
cout << "Aluno reprovado";
OBS: nas condições compostas, sempre será
utilizado um operador lógico.
TESTE CONDICIONAL
• Condições aninhadas:
– dentro de um comando condicional ("se
[senão]"), podemos ter diversos outros
comandos condicionais. Isto é conhecido como
"condições aninhadas"
www.upf.br
condições aninhadas .
12
TESTE CONDICIONAL
if (num > 10)
{
if (num == 15)
instruções;
www.upf.br
else
instruções;
}
else
instruções;
TESTE CONDICIONAL
• Várias condições independentes
– Quando necessário a realização de vários testes de forma
independente, ou seja, não sendo uma condição
composta, é permitido no comando ELSE (senão) iniciar
novamente um teste.
Exemplo
www.upf.br
Exemplo
if(media < 3) 
cout << "Reprovado";
else if (media < 7) 
cout << "Em exame";
else
cout << "Aprovado";
TESTE CONDICIONAL
• Em várias condições independentes, pode-se utilizar o
comando switch para substituir vários "else if", onde:
– Uma variável é testada sucessivamente contra uma
lista de variáveis inteiras ou de caracteres. Depois
d t i idê i d
www.upf.br
de encontrar uma coincidência, o comando ou o
bloco de comandos é executado.
– Se nenhuma coincidência for encontrada o comando
default será executado. O default é opcional. A
sequência de comandos é executada até que o
comando break seja encontrado.
TESTE CONDICIONAL
• Sintaxe do comando switch:
switch(variável)
{
case constante1:
sequência de comandos
www.upf.br
sequência de comandos
break;
case constante2:
sequência de comandos
break;
default:
sequência de comandos
}
TESTE CONDICIONAL
• Exemplo do comando switch:
switch(x)
{
case ‘A':
cout << "Você digitou a letra A" << endl;
www.upf.br
g
break;
case ‘B':
cout << "Você digitou a letra B" << endl;
break;
default:
cout << "Letra inválida" << endl;
}
• Atribuição Condicional
– Útil para simples condições de decisão
– Exemplo:
a = (a > 5) ? 10 : 50;
TESTE CONDICIONAL
www.upf.br
a = (a > 5) ? 10 : 50;
– Este comando é equivalente a:
if (a > 5)
a = 10;
else
a = 50;
13
Comandos de Repetição
www.upf.br
Comandos de Repetição
COMANDOS DE REPETIÇÃO
• Como o próprio nome diz, são comandos que
repetem sua execução (e de outros comandos
relacionados) até um determinado ponto,
quando encerram.
www.upf.br
• São vulgarmente conhecidos como "laços", ou
seja, quando chegamos ao final de um trecho de
programa "envolto" por um laço, retornamos ao
início do mesmo e o executamos novamente.
COMANDOS DE REPETIÇÃO
• Novos conceitos na utilização de variáveis:
– As variáveis vistas até agora serviram sempre
para o armazenamento de valores do
programa.
Uma variável era definida colocado um valor
www.upf.br
– Uma variável era definida, colocado um valor
nela via teclado (quando era lida) ou via
expressão numérica (comando de atribuição).
Seu valor era utilizado ou em testes ou em
cálculos e, finalmente, quando necessário, era
exposto. Todavia, veremos utilizações um
pouco mais inteligentes para as variáveis.
COMANDOS DE REPETIÇÃO
– Os tipos de variáveis não mudam, ou seja, os
tipos "integer", "float", "char", entre outros são
os mesmos; o que muda é o enfoque dado a
estas variáveis.
– Elas serão especialmente úteis em programas
www.upf.br
Elas serão especialmente úteis em programas
com repetição.
– São chamadas de contador, acumulador e
flag.
COMANDOS DE REPETIÇÃO
• Contador:
– Variável do tipo numérica inteira, que serve
para contar quantas vezes algum trecho de
programa foi executado (quantas vezes
alguma ação foi realizada)
www.upf.br
alguma ação foi realizada).
– Por exemplo: para sabermos quantas vezes
foi executado um bloco de comandos,
colocamos um comando a fim de incrementar
ou decrementar a variável contadora a cada
vez que o bloco é executado.
– Deve ser previamente inicializada.
COMANDOS DE REPETIÇÃO
• Acumulador:
– Variável que serve para acumular valores,
geralmente numéricos. Serve na prática para
obtermos uma determinada soma. Por
exemplo: para sabermos a soma de 30
www.upf.br
exemplo: para sabermos a soma de 30
números a serem lidos, junto com o trecho de
leitura atualizamos a variável acumuladora,
que já deve estar inicializada.
14
COMANDOS DE REPETIÇÃO
• Flag:
– Tradução do Inglês: bandeira ou sinal. É um
tipo de variável para controle do estado de um
programa. Usada em testes, serve na prática
para sabermos se um laço pode ou não
www.upf.br
para sabermos se um laço pode ou não
acabar, se uma fórmula foi ou não resolvida (o
programador deve saber os motivos, o porquê
da fórmula não ser resolvida).
– Possibilita a comunicação entre diversas
partes de um programa.
COMANDOS DE REPETIÇÃO
• Laço for (para):
– No Algoritmo:
para (<variavel> = <valor inicial> ; <condição parada> ;<incremento>)
inicio
Bloco de Comandos ou instrução;
www.upf.br
fim;
– Na linguagem C/C++:
for (<variavel> = <valor inicial> ; <condição parada> ; <incremento>)
{
Bloco de Comandos ou instruções;
}
COMANDOS DE REPETIÇÃO
• Exemplo:
for (x = 1; x <= 10 ; x++)
{ 
cout << "Digite o número: ";
www.upf.br
cout Digite o número: ;
cin >> num;
cin.clear();
soma = soma + num;
}
COMANDOS DE REPETIÇÃO
• A "variável" é uma variável contadora (inteira),
que é automaticamente controlada pelo laço e
incrementada de 1.
• O bloco de comandos vai ser executado tantas
www.upf.br
vezes quantas forem necessárias, enquanto a
"variável" mantém a condição de parada
verdadeira.
• No momento em que a condição de parada se
tornar falsa, o comando de repetição se encerra.
COMANDOS DE REPETIÇÃO
• A execução do laço "for" ocorre da seguinte
forma:
– No início da execução do comando, o valor
inicial é atribuído a variável contadora;
– Em seguida a condição de parada é avaliada:
www.upf.br
• Se for verdadeira, o bloco de comandos inicia sua execução;
• Caso contrário, o comando se encerra;
– Ao final do bloco de comandos, o incremento é
executado;
– Em seguida a condição de parada é avaliada.
• Se for verdadeira, o bloco de comandos reinicia sua execução;
• Caso contrário, o comando se encerra;
COMANDOS DE REPETIÇÃO
• Laço while (enquanto):
– O laço é executado enquanto a <condição> for 
verdadeira.
– No Algoritmo:
<variavel> = <valor inicial>
www.upf.br
<variavel> <valor inicial>
enquanto (<condição parada>)
inicio
Bloco de Comandos ou instrução;
<incremento da variável>;
fim;
15
COMANDOS DE REPETIÇÃO
– Na linguagem C/C++:
<variavel> = <valor inicial>;
while (<condição parada>)
{
Bloco de Comandos ou instruções;
www.upf.br
Bloco de Comandos ou instruções;
<incremento da variável>;
}
COMANDOS DE REPETIÇÃO
• Exemplo:
x = 1; 
while (x <= 10)
{ 
cout << "Digite o número: ";
www.upf.br
cout << Digite o número: ;
cin >> num;
cin.clear();
soma = soma + num;
x++;
}
COMANDOS DE REPETIÇÃO
• Ao chegar ao comando, a condição é avaliada.
Por isso, a variável a ser testada deve ser
inicializada.
• Se for "FALSE", o bloco de comandos não é
executado e a linha de execução passa para o
www.upf.br
executado, e a linha de execução passa para o
próximo comando após o delimitador de final de
bloco;
• Caso a condição avaliada seja "TRUE", o bloco
de comandos é executado, e ao final deste, a
condição é novamente avaliada, seguindo
novamente esta sistemática.
COMANDOS DE REPETIÇÃO
• A condição pode ser simples ou composta.
• O uso prático deste comando serve para casos
nos quais alguns comandos só precisam ser
repetidos quando e enquanto uma determinada
www.upf.br
condição for verdadeira.
• Este comando embute as funcionalidades de um
comando condicional, junto com um laço de
repetição, podendo a variável de controle ser
modificada nas instruções dentro do laço.
COMANDOS DE REPETIÇÃO
• Como o teste já é realizado no início do bloco,
a(s) variável(eis) envolvida(s) na condição devem
conter um valor antes do inicio do comando.
• A variável de controle pode ser um acumulador e
www.upf.br
não necessariamente um contador, podendo com
isso ser adicionado valores diferentes de 1.
COMANDOS DE REPETIÇÃO
• Laço do (faça) while (enquanto):
– O laço é executado enquanto a <condição> for 
verdadeira.
– No Algoritmo:
<variavel> = <valor inicial>;
www.upf.br
;
faça
inicio
Bloco de Comandos ou instrução;
<incremento da variável>;
fim;
enquanto (<condição parada>);
16
COMANDOS DE REPETIÇÃO
– Na linguagem C/C++:
<variavel> = <valor inicial>;
do
{
Bloco de Comandos ou instruções;
www.upf.br
Bloco de Comandos ou instruções;
<incremento da variável>;
} while (<condição parada>);
COMANDOS DE REPETIÇÃO
• Exemplo:
x = 1; 
do
{ 
cout << "Digite o número: ";
www.upf.br
cout << Digite o número: ;
cin >> num;
cin.clear();
soma = soma + num;
x++;
} while (x <= 10);
COMANDOS DE REPETIÇÃO
• A diferença do do while para o comando while é
que no do while o bloco de comandos é
executado antes de avaliar a condição, ou seja,
neste caso, independentemente do resultado do
teste, o bloco de comandos é executado no
mínimo uma vez o que não acontece no
www.upf.br
mínimo uma vez, o que não acontece no
comando while, onde o teste é verificado antes de
iniciar a execução do bloco de comandos.
COMANDOS DE DESVIO
• Break e Continue
– Servem para abortar a execução da partes de 
um bloco, ou encerrar a execução deste
– O comando break encerra o laço no ponto em 
que for executado
www.upf.br
q
– O comando continue desvia o fluxo para o 
início do laço
– Estes dois comandos funcionam com todos os
comandos de repetição
COMANDOS DE DESVIO
• Exemplo: break
#include <iostream> 
using namespace std;
main() 
{ 
int cont, num; 
www.upf.br
for (cont = 1; cont <= 3; cont ++) 
{ 
cout << "Entre com um numero";
cin >> num;
cin.clear();
if (num < 0)
break; // encerra o laço neste ponto !!! 
}
cout << "Quantidade: " << cont-1;
}
COMANDOS DE DESVIO
• Exemplo: continue
#include <iostream> 
using namespace std;
main() 
{ 
www.upf.br
int cont; 
for (cont = 1; cont <= 5; cont++) 
{ 
if(cont % 2 == 0)
continue; /* permanece no laço, mas não executa os próximos 
comandos do bloco de repetição */
cout << "Passo " << cont << " de repeticao" << endl;
}
17
Estrutura de dados
www.upf.br
Estrutura de dados
struct
• O conceito de orientação a objeto tem uma base muito
sólida no conceito de estrutura de dados. As estruturas
de dados consistem na criação de um único dado, o
qual contém vários membros (que nada mais são do que
outras variáveis). De uma forma mais simples, é como
se uma variável tivesse outras variáveis dentro dela
ESTRUTURA DE DADOS
www.upf.br
se uma variável tivesse outras variáveis dentro dela.
• Como principal vantagem, estruturas de dados
possibilitam agrupar, de forma organizada, vários tipos
diferentes de dados. Por exemplo, dentro de uma
estrutura de dados, podemos ter juntos tanto um tipo
float, um inteiro, um char ou um double.
• Criando uma estrutura de dados com STRUCT
• Para criar uma estrutura de dados, usamos a palavra
reservada struct. Toda estrutura deve ser criada antes
de qualquer função ou mesmo da função principal
"main". Toda estrutura tem nome, e seus membros são
declarados dentro de um bloco de dados Após a
ESTRUTURA DE DADOS
www.upf.br
declarados dentro de um bloco de dados. Após a
definição de seus membros no bloco de dados,
terminamos a linha com um ponto-e-vírgula (;). Portanto:
struct nome_da_estrutura
{
tipo_de_dado nome; 
};
Por exemplo, se fossemos criar uma estrutura de dados
para as notas do semestre de um aluno:
struct notas
{
ESTRUTURA DE DADOS
www.upf.br
{
float prova1;
float prova2;
};
Declarando um struct e acessando seus membros
#include <iostream>
using namespace std;
ESTRUTURA DE DADOS
www.upf.br
struct notas
{
float prova1;
float prova2;
};
mainmain()()
{{
notas aluno; notas aluno; 
floatfloat media;media;
aluno.prova1 aluno.prova1 = = 8.2;8.2;
ESTRUTURA DE DADOS
www.upf.br
pp ;;
aluno.prova2 aluno.prova2 = = 9.1;9.1;
media = (aluno.prova1 + aluno.prova2)/2;media = (aluno.prova1 + aluno.prova2)/2;
coutcout << "A media das notas: " << media << << "A media das
notas: " << media << endlendl;;
cin.synccin.sync();();
cin.getcin.get(); (); 
}}
18
Funções
www.upf.br
Funções
FUNÇÕES
• As funções são úteis para uma série de
problemas relacionados a algoritmos. Vamos
utilizar funções para realizar uma "quebra" do
algoritmo em partes menores. A quebra será
realizada de modo que cada função execute
www.upf.br
q ç
uma parte da solução.
• Funções são subalgoritmos que podem retornar
um valor.
FUNÇÕES
• A definição de uma função deve ocorrer na área
destinada as funções: após a definição das
variáveis e antes do programa principal. Caso a
definição ocorra depois do programa principal, é
necessário declará-la no início do programa.
Esta declaração é feita por meio do protótipo da
www.upf.br
Esta declaração é feita por meio do protótipo da
função. O protótipo da função nada mais é do
que o trecho de código que especifica o nome e
os parâmetros da função.
FUNÇÕES
• Para que uma função seja definida, basta
informar o tipo de retorno (int, float, etc...).
Quando uma função não retorna valores, usa-se
"void". Em seguida, atribui-se um nome para a
função (por exemplo "calculo"), seguido de um
abre e fecha parênteses Os parênteses serão
www.upf.br
abre e fecha parênteses. Os parênteses serão
utilizados para proporcionar maiores
funcionalidades.
FUNÇÕES
• Após os parênteses, deve-se incluir os
delimitadores de inicio e fim de bloco, um abre
chaves "{" e um fecha chaves "}",
respectivamente.
O d d b l i (f ) d
www.upf.br
• Os comandos do subalgoritmo (função) devem
ser colocados de forma análoga a um algoritmo.
• Na linguagem C++ não é necessário utilizar a
definição "function" para identificar uma função.
FUNÇÕES
• Para a definição dos nomes das funções, deve-se
seguir as regras dos identificadores e da mesma
forma não podem haver nomes de funções
repetidos. Os nomes das funções também não
podem ser iguais a nomes de variáveis ou
t t U d ã d
www.upf.br
constantes. Um dos nomes que não podemos
utilizar é "main", pois estaríamos nos referindo a
parte principal do algoritmo.
19
FUNÇÕES
• Salienta-se que mesmo que se escreva as
funções, o que comanda o algoritmo é o
programa principal, dessa forma as funções
devem ser chamadas pelo programa principal.
www.upf.br
• Geralmente a chamada das funções é realizada
no programa principal (que também pode ser
considerado uma função). Porém, pode-se
chamar uma função dentro de outra função,
desde que a função que está sendo chamada
tenha sido definida antes da função que a
chamou.
FUNÇÕES
• Após a chamada para execução de uma função,
o ponto de execução é deslocado para o
primeiro comando da função (subalgoritmo) e
segue executando sequencialmente, da mesma
forma como um algoritmo. Ao alcançar o final da
www.upf.br
g ç
função, o ponto de execução volta para o
comando subsequente da chamada da função.
FUNÇÕES
• Para chamar uma função basta informar seu
nome, seguido de abre e fecha parênteses.
Ex.: 
calculo();
www.upf.br
calculo();
• Caso a função necessite de parâmetros de
entrada, os mesmos devem ser passados quando
da chamada da função, escrevendo-os dentro dos
parênteses na ordem que foram declarados na
função.
VARIÁVEIS
• Como já mencionado, existem variáveis globais
e locais, o que requer atenção especial durante
o trabalho com funções.
• As variáveis definidas na "área de definição de
www.upf.br
variáveis" de um algoritmo/programa, são
consideradas globais. Elas são conhecidas em
todas as partes e seu valor também pode ser
verificado ou incluso em operações aritméticas
nas diferentes partes do programa.
VARIÁVEIS
• Ocasionalmente, uma variável é utilizada em
apenas uma função, torna-se pouco cômodo
deixar sua definição na área das globais. Para
isto, podemos incluir uma nova seção de
variáveis, logo após a declaração da função,
definindo nela as que serão usadas somente na
www.upf.br
definindo nela as que serão usadas somente na
função em questão. A estas variáveis, declaradas
na parte interna de uma função, damos o nome
de "variáveis locais".
VARIÁVEIS
• Ex.:
www.upf.br
20
VARIÁVEIS
• Nenhuma relação existe entre uma variável local
e uma global, ainda que definidas com o mesmo
nome.
• É totalmente desaconselhável a definição de uma
iá l l l d l b l
www.upf.br
variável local com o mesmo nome de uma global,
a fim de evitar confusão por parte do
programador.
• O programa não faz confusão, porém o
programador pode facilmente se confundir.
VARIÁVEIS
• A grande vantagem das variáveis locais é que o
espaço de armazenamento destas na memória,
só é efetivamente ocupado quando a função é
executada.
A fi l d é lib d
www.upf.br
• Ao final da execução, esse espaço é liberado
para a memória livre. Com isso, os programas
ficam mais "leves", ou seja, ocupam menos
memória.
PARÂMETROS
• A passagem de parâmetros é uma necessidade
para a programação. Ela possibilita o
reaproveitamento de código, de maneira a tornar
o programa mais limpo, curto e fácil de entender.
N d i é d h d f ã
www.upf.br
• Nada mais é do que a chamada a uma função,
estabelecendo valores iniciais dos dados que
este subprograma manipula.
• Rotinas com passagem de parâmetros devem ser
escritas sempre que um determinado "bloco de
código" se repete.
PARÂMETROS
• Quando uma função é definida para receber
parâmetros, a chamada destes deve
obrigatoriamente ser acompanhada dos valores
dos argumentos, que devem ser passados na
mesma ordem e na mesma sequência em que
foram definidos
www.upf.br
foram definidos.
• A mesma quantidade de parâmetros definidos
deve ser passada na chamada da função, sob
pena de erros de compilação.
PARÂMETROS
• Existem duas formas de passagem de parâmetro
para funções:
• Por valor
– Existe uma cópia dos valores das variáveis
www.upf.br
utilizadas na chamada da função para os
parâmetros e não é ocupado a mesma posição
na memória. Por isso, modificações feitas nos
parâmetros não alteram o valor das variáveis.
PARÂMETROS
Exemplo:
int calcula(int a, int b)
{
a = 8;
res = a + b;
return res; 
}
www.upf.br
}
main()
{
x = 4;
y = 2;
cout<<"Resultado: "<<calcula(x, y);
cin.sync();
cin.get();
}
21
PARÂMETROS
• Por Referência:
– Neste tipo de passagem de parâmetro as
variáveis ocupam a mesma posição na
memória, é passado para a função o endereço
da variável utilizada na chamada. Assim sendo,
difi l d â t tá
www.upf.br
ao se modificar o valor do parâmetro está
sendo alterado o valor da variável também.
PARÂMETROS
Exemplo:
int calcula(int &a, int &b)
{
a = 8;
res = a + b;
return res; 
}
www.upf.br
}
main()
{
x = 4;
y = 2;
cout<<"Resultado: "<<calcula(x, y);
cin.sync();
cin.get();
}
PARÂMETROS
• Os parâmetros dentro de uma função são
considerados variáveis locais, ou seja, só existem
dentro dele próprio. Ainda por serem variáveis
locais, os parâmetros não necessitam de uma
definição prévia na área de definições de
variáveis e também não necessitam ser definidos
www.upf.br
variáveis, e também não necessitam ser definidos
como variáveis locais, porque a própria definição
ao lado do nome da função se encarrega disso.
Vetores e Matrizes
www.upf.br
Vetores e Matrizes
VETORES E MATRIZES
• As linguagens de programação nos
proporcionam a utilização de variáveis que não
armazenam um único dado, mas conjuntos de
dados.
www.upf.br
• Entre as variáveis que armazenam conjuntos de
dados, encontramos os mais simples
denominados conjuntos de dados de mesmo
tipo. Variáveis com essas características são
conhecidos como vetores e matrizes.
VETORES E MATRIZES
• São chamadas também de variáveis
dimensionadas e obrigatoriamente devem ser
indexadas, ou seja, devem ser acessadas e/ou
manipuladas através do uso de seus índices.
www.upf.br
• Os índices das variáveis dimensionadas variam
de 0 até o limite da dimensão menos uma
unidade, sendo sempre valores inteiros.
22
VETORES E MATRIZES
• Para especificar um vetor, adiciona-se após o
nome da variável a quantidade de elementos
que desejamos armazenar dentro de colchetes.
Salienta-se que a quantidade de elementos deve
ser sempre inteira, porém os dados que serão
armazenados no vetor podem ser de outros tipo
www.upf.br
armazenados no vetor podem ser de outros tipo
como float, char, etc...
• Ex.
int a[10];
float b[8];
VETORES E MATRIZES
• O acesso aos elementos dentro de um vetor é
realizado através das posições. Os índices das
i õ ã l i t i É
www.upf.br
posições são sempre valores inteiros. É
importante salientar que apenas os índices
devem ser inteiros e que os valores dos
elementos podem ser de qualquer tipo (definidos
na declaração das variáveis).
VETORES E MATRIZES
• É importante lembrar a diferença entre o valor do
elemento de um vetor e o valor de seu índice. Os
índices são sempre fixos, sua ordem é crescente
do valor inicial até o final. O conteúdo de uma
posição apontada por um índice é chamado de
www.upf.br
p ç p p
"valor do elemento" ou simplesmente
"elemento".
• Relembrando, o valor do índice não possui
nenhuma relação com o valor do seu conteúdo.
UMA DIMENSÃO
• Leitura de valores com uma dimensão
for(i = 0; i < 10; i++)
{
cout<<"Digite um valor: ";
www.upf.br
cout Digite um valor: ;
cin>>a[i];
cin.clear();
}
UMA DIMENSÃO
• Escrita de valores com uma dimensão:
for(i = 0; i < 10; i++)
{
cout<<a[i]<<" – ";
www.upf.br
cout a[i] ;
}
VETORES E MATRIZES
• A utilização de uma variável como índice de um
vetor não decreta sua utilização como sendo
exclusivo deste vetor. Esta variável pode ser
utilizada como índice em outro vetor ou até para
outras funcionalidades. Do mesmo modo, um
www.upf.br
vetor pode ser acessado utilizando diversos
índices. Todavia, o mais importante é controlar a
ação desejada, ou seja, se o valor da variável
utilizada como índice está com seu valor correto
ou desejado.
23
DUAS DIMENSÕES
• Matrizes com duas dimensões possuem dois
índices, um para controlar a coluna e outro para
controlar a linha, para acessar ou manipular
informações neste tipo de estrutura é necessário
dois índices.
www.upf.br
• Para declarar uma matriz basta definir o tipo e as
dimensões.
• Ex. int x[3][4];
- Cria uma matriz de 3 x 4 sendo possível armazenar
valores inteiros.
DUAS DIMENSÕES
www.upf.br
DUAS DIMENSÕES
• Leitura de matriz com duas dimensões
for(a = 0; a < 4; a++)
{
for(b = 0; b < 3; b++)
{
www.upf.br
{ 
cout<<"Digite um valor: ";
cin>>x[a][b];
cin.clear();
}
}
DUAS DIMENSÕES
• Escrita de matriz com duas dimensões
for(a = 0; a < 4; a++)
{
for(b = 0; b < 3; b++)
www.upf.br
{ 
cout<< x[a][b] << "\t"; 
}
cout << endl;
}
DUAS DIMENSÕES
www.upf.br
Manipulação de Arquivos
www.upf.br
Manipulação de Arquivos
24
ARQUIVOS TEXTO
• A linguagem C/ C++ possibilita inúmeras funções
ou comandos para manipulação de arquivos
texto, sendo possível abrir, fechar, ler e escrever
informações nesses arquivos.
www.upf.br
• Em C++, essas funções ou recursos são
chamadas de métodos, pois trabalham com o
conceito de orientação a objeto. Neste caso, uma
variável ou instância pode representar um stream
(conjunto de dados) de entrada ou saída para,
respectivamente, permitir a leitura ou a gravação
de dados.
GRAVANDO UM STREAM
• Primeiramente, deve-se incluir a biblioteca padrão
para manipulação de arquivos "file streams" em
C++ no cabeçalho do arquivo:
#include<fstream>
www.upf.br
• A seguir, na função desejada, cria-se uma variável 
para o arquivo de saída (instância de "ofstream"):
ofstream arquivoSaida;
GRAVANDO UM STREAM
• O próximo passo é abrir o arquivo, usando o 
modo "ios::out", que cria o arquivo e abre para 
escrita. Cuidado: se esse modo for usado em 
arquivos já existentes, eles serão apagados! 
arquivoSaida.open("nomedoarquivo.txt", 
www.upf.br
ios::out);
• O método "is_open" retorna FALSE se o arquivo 
não está aberto, então usamos para testar se foi 
possível realizar a operação.
if (! arquivoSaida.is_open())
return 0;
GRAVANDO UM STREAM
• Agora, podemos gravar os dados de forma fácil e 
direta:
arquivoSaida << "Grava 1a linha" << endl;
arquivoSaida << "Grava 2a linha" << endl;
arquivoSaida << "Grava 3a linha" << endl;
www.upf.br
arquivoSaida << Grava 3a linha << endl;
• Ao final, fechamos o arquivo, salvando os dados:
arquivoSaida.close();
EXEMPLO DE GRAVAÇÃO
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
ofstream arquivoSaida;
arquivoSaida.open ("cadastro.txt", ios::out);
if (!arquivoSaida.is open())
www.upf.br
q _ p
return 0;
arquivoSaida << "Teste de gravação" << endl;
arquivoSaida << "...nova linha..." << endl;
arquivoSaida << "123 números e símbolos #@$" << endl;
arquivoSaida.close();
cout << "Arquivo gravado com sucesso!";
cin.sync();
cin.get();
return 0;
}
GRAVANDO UM STREAM
• Caso seja preciso abrir um arquivo existente para 
adicionar dados, sem apagá-lo, devemos usar o 
modo "ios::app".
arquivoSaida.open("nomedoarquivo.txt", 
ios::app);
www.upf.br
• O restante do procedimento continua o mesmo.
• IMPORTANTE: sempre feche o arquivo antes de 
finalizar o programa, para garantir que os dados 
sejam salvos corretamente.
25
LENDO UM STREAM
• Para ler um arquivo, o procedimento é similar
• Verifica-se a inclusão da biblioteca "fstream" no 
cabeçalho do programa:
#include<fstream>
www.upf.br
#include<fstream>
• Na função desejada, cria-se uma variável para o 
arquivo de entrada (instância de "ifstream")
ifstream arquivoEntrada;
LENDO UM STREAM
• Em seguida, define-se o modo "ios::in" para 
abertura do arquivo para leitura:
arquivoEntrada.open("nomedoarquivo.txt",
ios::in);
www.upf.br
• Neste caso, utilizamos o método "is_open" com 
dois propósitos: verificar se o arquivo está aberto 
e se ele existe. Retornando FALSE, finaliza o 
procedimento:
if (! arquivoEntrada.is_open())
return 0;
LENDO UM STREAM
• A seguir, usamos o método "eof" (end of file) como 
condição para um laço de repetição. Enquanto 
retornar FALSE, ele executará os comandos do 
bloco de repetição. Caso contrário, informará ao 
programa que a leitura alcançou o fim do arquivo:
www.upf.br
while(!arquivoEntrada.eof()
{
// comandos
}
LENDO UM STREAM
• Dentro do bloco de repetição, podemos ler linha a 
linha de um arquivo usando o método "getline":
char str[1000];
// …
while(!arquivoEntrada eof())
www.upf.br
while(!arquivoEntrada.eof())
{
arquivoEntrada.getline(str, 1000);
cout << str << endl;
}
LENDO UM STREAM
• Após ler e imprimir os dados, alcançando o fim do 
arquivo, finalizamos o procedimento fechando o 
arquivo fora do bloco de repetição:
arquivoEntrada.close();
www.upf.br
• IMPORTANTE: os dados lidos não serão 
apagados do arquivo durante o procedimento de 
leitura.
EXEMPLO DE LEITURA
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
char str[1000];
ifstream arquivoEntrada;
arquivoEntrada.open ("cadastro.txt", ios::in);
if (! i d i ()) 0
www.upf.br
if (!arquivoEntrada.is_open()) return 0;
while(!arquivoEntrada.eof())
{
arquivoEntrada.getline(str, 1000);
cout << str << endl;
}
arquivoEntrada.close();
cin.sync();
cin.get();
return 0;
}
26
LENDO UM STREAM
• Se não desejarmos ler linha por linha do arquivo, 
existe a opção de ler palavra por palavra. Neste 
caso, não utilizamos o bloco de repetição. O 
acesso é direto:
char str[1000];
www.upf.br
// …
arquivoEntrada >> str;
cout << str; // Imprime a 1a palavra do arquivo
arquivoEntrada >> str;
cout << str; // Imprime a 2a palavra do arquivo
REFERÊNCIAS
• DEITEL, Harvey M.; DEITEL, Paul J.; LUCCHINI,
Fábio Luis Picelli (Rev.). C++: como programar.
5. ed. São Paulo: Pearson Prentice Hall, 2006.
• http://www.cplusplus.com/
www.upf.br
• http://www.cppreference.com/wiki/start
• Bjarne Stroustrup's Homepage. Disponível em:
http://www2.research.att.com/~bs/
REFERÊNCIAS
• SCHILDT, Herbert. C completo e total. 3. ed. São
Paulo: Makron Books, 1997.
• KERNIGHAN, Brian W.; RITCHIE, Dennis M. C:
a linguagem de programação. Rio de Janeiro:
Campus 1986
www.upf.br
Campus, 1986.
• KERNIGHAN, Brian W.; RITCHIE, Dennis M. C:
a linguagem de programação : padrão ANSI. Rio
de Janeiro: Campus, 1990.
• REBONATTO, Marcelo. Notas de Aula –
Conceitos Básicos.
www.upf.br