O documento apresenta a biografia de um professor de programação estruturada, contendo informações sobre sua formação acadêmica, experiência profissional e links de contato. O documento também descreve o curso de programação estruturada ministrado pelo professor, com informações sobre o título, o nome do professor e a instituição onde é lecionado.
2. Apresentação
Prof. Thomás da Costa
- Graduado em Gestão em Tecnologia da Informação pela UNIP
- MBA em Arquitetura de Soluções pela FIAP
- 19 anos de experiência na área de Informática
- 14 anos de experiência com desenvolvimento em Java
- Certificação Java Programmer (SCJP)
- Desenvolvimento e arquitetura de aplicações em várias áreas
- Experiência profissional com várias linguagens e ferramentas de desenvolvimento PHP,
C#, C, JavaScript, Java SE, Java EE, Spring Core, Spring MVC, JBoss Seam, Hibernate
- Atualmente sou líder de uma equipe de desenvolvimento para um projeto na área
bancária
https://www.linkedin.com/in/thomasdacosta
https://www.facebook.com/thomasdacosta
@thomasdacostadev
https://github.com/thomasdacosta
Prof. Thomás da Costa Programação Estruturada II
4. Revisão
Estrutura de um programa C++:
Revisão
#include <iostream>
using namespace std;
int main()
{
cout << "Olá Mundo !!!";
}
Bibliotecas de funções
Função principal do programa
Identificador da função
Prof. Thomás da Costa Programação Estruturada II
5. Revisão
Variáveis:
Revisão
#include <iostream>
using namespace std;
int main()
{
const float numero_pi = 3.14;
char genero = 'M';
int idade = 31;
float nota_final = 8.5;
double salario = 1200.12;
cout << "Variáveis:" << genero << "," << idade << "," << nota_final
<< "," << salario << "," << numero_pi << endl;
double nota1, nota2;
cout << "Digite as notas:" << endl;
cin >> nota1 >> nota2;
cout << "Notas: " << nota1 << "-" << nota2;
}
Tipo da variável
Nome da variável
Ler uma variável a partir
do teclado
Prof. Thomás da Costa Programação Estruturada II
6. Revisão
Operadores:
Revisão
#include <iostream>
using namespace std;
int main()
{
int x = 10 + 5;// soma
int y = 4 - 20;// subtração
int j = 34 * 160;// multiplicação
int i = 6 / 2;// divisão
int p = 150 % 2;// resto da divisão
int acelerar = 100;// incremento pós-fixado
acelerar++;
int desacelerar = 100;// decremento pós-fixado
desacelerar--;
}
#include <iostream>
using namespace std;
int main()
{
int correr = 20;// incremento pré-fixado
++correr;
int andar = 30;// decremento pré-fixado
--andar;
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int e = 5;
a += 1;// atribuição soma
b -= 1;// atribuição subtração
c *= 1;// atribuição multiplicação
d /= 1;// atribuição divisão
e %= 1;// atribuição resto da divisão
}
Prof. Thomás da Costa Programação Estruturada II
7. Revisão
Desvios Condicionais:
Revisão
#include <iostream>
using namespace std;
int main()
{
int idade;
cout << "Digite sua idade:";
cin >> idade;
if (idade >= 21)
{
cout << "Maior de idade";
}
else
{
cout << "Menor de idade";
}
}
#include <iostream>
using namespace std;
int main()
{
int opcao;
cout << "Informe uma opção (1,2,3):";
cin >> opcao;
switch (opcao)
{
case 1:
cout << "Opção 1 Selecionada";
break;
case 2:
cout << "Opção 2 Selecionada";
break;
case 3:
cout << "Opção 3 Selecionada";
break;
default:
cout << "Nenhuma Opção Selecionada";
break;
}
}
Condição
Condições
Prof. Thomás da Costa Programação Estruturada II
8. Revisão
Laço (Loops):
Revisão
#include <iostream>
using namespace std;
int main()
{
for (int i=0;i<=10;i++)
{
cout << i << "n";
}
int j = 0;
while (j <=10)
{
cout << j << "n";
j++;
}
int k = 0;
do
{
cout << k << "n";
k++;
}
while (k <= 10);
}
Condição inicial, final
do loop e contador
Condição do loop. Pode
não entrar na rotina
Condição do loop, passa pelo
menos uma vez na rotina
Prof. Thomás da Costa Programação Estruturada II
9. Revisão
Vetores:
Revisão
#include <iostream>
#include <string.h>
using namespace std;
int main()
{
int k[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // inicializando um vetor
for (int i=9;i>=0;i--)
{
k[i] = i;
cout << k[i] << "n";
}
char nome1[10] = "João"; // uma string
char nome2[10] = "Maria";
strcat(nome2, " das Graças"); // concatena duas strings
cout << "Nome1, Nome2: " << nome1 << "," << nome2 << "n";
cout << "Tamanho do Nome1: " << strlen(nome1) << "n"; // tamanho de uma string
cout << "Tamanho do Nome2: " << strlen(nome2) << "n";
cout << "Comparando:" << strcmp(nome1, nome2) << "n"; // compara duas strings
char usuario[100];
gets(usuario);// lê a string do teclado
cout << "Usuário: " << usuario;
}
Criando um vetor com 10 posições
Inicializando um vetor
Atribuindo um
valor na posição
Ler um vetor de char
pelo teclado
Prof. Thomás da Costa Programação Estruturada II
11. Depuração e Documentação
O que é:
É uma técnica para executar uma aplicação passo a passo, identificando possíveis
erros (bug) ou para o entendimento de uma funcionalidade do programa pelo
desenvolvedor.
Depuração ou Debug
Prof. Thomás da Costa Programação Estruturada II
12. Depuração e Documentação
Mais um pouco:
- Executa o programa linha a linha
- Visualizar valores das variáveis em tempo de execução
- Breakpoints
- Analise das funções do código fonte
Depuração ou Debug
BUGS = DEFEITOS = ERROS
Prof. Thomás da Costa Programação Estruturada II
13. Depuração e Documentação
Como fazer análise de um erro:
Tendo a premissa que conhecemos o programa a ser depurado, podemos seguir os
seguintes passos:
- 1º Passo:
- Verificar o problema reportado (normalmente por um usuário)
- 2º Passo:
- Entender o problema
- 3º Passo:
- Conhecer os parâmetros do usuário
- 4º Passo:
- Reproduzir o problema (isso pode ser extremamente difícil)
- 5º Passo:
- Após conseguir reproduzir o problema, efetuar a leitura do código e ver
possíveis erros de codificação ou utilizar uma ferramenta de depuração
Depuração ou Debug
Prof. Thomás da Costa Programação Estruturada II
14. Depuração e Documentação
Depuração ou Debug
Análise de Código:
No caso do código abaixo, conseguimos identificar um possível problema em nosso
programa ?
Sim temos !!!
Nosso vetor de inteiros, possui 10 posições e
para percorrer um vetor é sempre a posição – 1.
Então o i <= 10 deveria ser i <= 9
#include <iostream>
using namespace std;
int main()
{
int value[10];
int i = 0;
for (;i<=10;i++)
{
value[i] = i;
cout << i;
}
}
Prof. Thomás da Costa Programação Estruturada II
15. Depuração e Documentação
Depuração ou Debug
Debug no DevC++:
Muitas vezes efetuamos a análise do código, e não conseguimos identificar o
problema, pois o código pode ser extenso ou de difícil compreensão. Por isso as
ferramentas modernas, possuem funcionalidades que permitem rodar o programa
linha a linha.
Caçando os BUGS !!!
Prof. Thomás da Costa Programação Estruturada II
16. Depuração e Documentação
Depuração ou Debug
Breakpoints:
São marcações efetuadas na ferramenta, que tem como finalidade interromper o
programa na linha selecionada, até que o desenvolvedor continue para a próxima
instrução. Na imagem abaixo, o programa interrompe na linha 12.
Marcação do breakpoint
Prof. Thomás da Costa Programação Estruturada II
18. Depuração e Documentação
Depuração ou Debug
Watch:
No processo de depuração conseguimos visualizar os valores das variáveis em
tempo de execução. Para isso usamos o botão Add watch. Na barra lateral
podemos ver as variáveis do programa sendo preenchidas
Valores das variáveis em
tempo de execução
Botão Add Watch
Prof. Thomás da Costa Programação Estruturada II
21. Depuração e Documentação
Documentação
Sempre !!!:
Documentação do código serve principalmente quando outro desenvolvedor
precisa efetuar uma manutenção no programa. Podemos criar uma documentação
através de comentários dentro do código.
A documentação de um código pode ser feita com:
// - quando for uma linha
/** **/ - quando for um bloco de texto em mais de uma linha
Prof. Thomás da Costa Programação Estruturada II
22. Depuração e Documentação
Bloco de comentário
Comentário em linha
#include <iostream>
using namespace std;
/**
Autor: Thomás da Costa
Data de Criação: 01/01/2015
Titulo: Programa que efetua o cálculo de uma progressão aritmética
Descritivo: Progressão aritmética é um tipo de seqüência numérica que a partir
do segundo elemento cada termo (elemento) é a soma do seu antecessor por uma constante.
**/
int main()
{
const int TOTAL_PA = 10; // Limite total da progressão aritmética
int razao = 2; // Razão da progressão
int i = 0; // Indice para efetuar o loop da progressão
int resultadoPa = 0;// Resultado da posição da PA
int resultadoAntPa = 3;// Resultado anterior da posicao da PA
// Efetuado o cálculo da progressão de acordo
for (;i<=TOTAL_PA;i++)
{
// Cálculo da progressão ocorre indice atual mais a razão
resultadoPa = resultadoAntPa + razao;
resultadoAntPa = resultadoPa;
// Imprime valor na tela da PA
cout << resultadoPa << "n";
}
}
Prof. Thomás da Costa Programação Estruturada II
23. Depuração e Documentação
Resumo
- Depuração é o processo de identificação erros dentro de uma aplicação
- Podemos conhecer a funcionalidade de um programa
- Na depuração o programa é executado linha a linha
- Bugs são defeitos no programa
- Documentação é importante quando vamos efetuar a manutenção de um
programa
Prof. Thomás da Costa Programação Estruturada II
25. Depuração e Documentação
Exercícios
1 – Código abaixo mostra todas as tabuadas, mas o programa está mostrando
somente a tabuada do 1. Identifique o erro.
#include <iostream>
using namespace std;
int main()
{
int i=1;
int j=1;
for (;i<=10;i++)
{
for (;j<=10;j++)
{
cout << i << "x" << j << "=" << (i * j) << "n";
}
cout << "n";
}
}
Prof. Thomás da Costa Programação Estruturada II
26. Depuração e Documentação
Exercícios
2 – Programa abaixo efetua o cálculo do fatorial de 6, mas o usuário reclamou
dizendo que o valor não é exibido na tela. Qual o problema com o programa?
#include <iostream>
using namespace std;
int main()
{
int fat=6;
int fatorial = 1;
while (fat >= 1)
{
fatorial *= fat;
}
cout << fatorial << "n";
}
Prof. Thomás da Costa Programação Estruturada II
27. Depuração e Documentação
Exercícios
3 – Este programa mostra os números pares e impares de 100 até 1. Mostre todos
os possíveis problemas encontrados no programa.
#include <iostream>
using namespace std;
int main()
{
for (int k=100;k>=1;k++)
{
int ret = k % 2;
if (ret = 0)
{
cout << "Par:" << k << "n";
}
else
{
cout << "Impar:" << k << "n";
}
}
}
Prof. Thomás da Costa Programação Estruturada II
29. Modularização e Funções
O que é Modularização:
É o processo de decompor um programa em partes menores, facilitando a
manutenção e o entendimento pelos desenvolvedores. Com isso podemos ter
rotinas reutilizáveis para outros programas e aplicações. Além disso, conseguimos
efetuar atividades paralelas na construção do código-fonte, na qual mais de um
desenvolvedor pode atuar no trabalho.
Modularização e Funções
Prof. Thomás da Costa Programação Estruturada II
30. Modularização e Funções
Veja o exemplo abaixo:
Um carro é composto por vários componentes (portas, rodas, motor e etc). Esses
componentes tornam o carro modular.
Modularização e Funções
Cada parte tem uma finalidade, todas
juntas formam o carro. Caso uma peça tenha problema,
fazemos o ajuste neste local sem
afetar o restante do carro.
Prof. Thomás da Costa Programação Estruturada II
31. Modularização e Funções
Benefícios da Modularização em um programa:
- Componentes menores formam um programa
- Programa fica mais legível para compreensão
- Facilidade na manutenção da aplicação
- Funcionalidade pode ser reutilizada em outros programas
- Previne duplicação de código e retrabalho
Modularização e Funções
Prof. Thomás da Costa Programação Estruturada II
32. Modularização e Funções
Modularização em C/C++:
Em C++ a modularização é feita a partir de blocos de funcionalidades, denominado
funções.
Modularização e Funções
Prof. Thomás da Costa Programação Estruturada II
33. Modularização e Funções
O que é:
São rotinas que tem como objetivo, executar trechos de códigos de forma
modular, melhorando a organização do programa e evitando repetição de código.
As funções são reutilizáveis dentro de um programa.
Funções
Prof. Thomás da Costa Programação Estruturada II
34. CALCULADORA
Modularização e Funções
Funções
Para pensar:
Em uma calculadora quais são as suas 4 principais operações?
SOMA
MULTIPLICAÇÃO DIVISÃO
SUBTRAÇÃO
Conseguimos definir as 4 principais
operações da calculadora.
No desenvolvimento do código da
calculadora vamos precisar criar as 4
funções de acordo com as operações
definidas.
35. Modularização e Funções
Funções
Como criar funções:
- Análise quais tarefas o programa vai executar
- Identifique ações
- Ações são verbos como inserir, alterar, excluir e etc.
- A partir das ações temos as funções
Mais um exemplo:
Quais as funções da lista de contatos de um celular?
- Inserir um Contato
- Alterar um Contato
- Excluir um Contato
- Discar para um Contato
Prof. Thomás da Costa Programação Estruturada II
36. Modularização e Funções
Funções
Estrutura de uma função:
Retorno da função
Nome da função
Parâmetros da função
Corpo da função
Escopo de início e fim da função
double somar(double x, double y)
{
double resultado = x + y;
return resultado;
}
Prof. Thomás da Costa Programação Estruturada II
37. Modularização e Funções
Funções
Estrutura de uma função:
- Tipos de retorno da função
- double, float, int, char, void, vetores e outros tipos
- Parâmetros da função
- Cada parâmetro é composto pelo tipo, nome e separados por virgulas
- Retorno da função
- Quando uma função deve retornar um valor, devemos usar a palavra
reservada return seguido de um valor, variável ou operação do mesmo tipo
de retorno
- Corpo da função
- Código fonte com a funcionalidade que a função deve executar
- Protótipo
- As funções possuem protótipos para definir sua estrutura
Prof. Thomás da Costa Programação Estruturada II
38. Modularização e Funções
Funções
Como Utilizar em C++:
As quatro funções da calculadora
Protótipo das funções
#include <iostream>
using namespace std;
double somar(double x, double y);
double subtrair(double x, double y);
double multiplicar(double x, double y);
double dividir(double x, double y);
int main()
{
double x, y;
cout << "Digite os valores para somar:n";
cin >> x >> y;
cout << somar(x, y);
cout << "Digite os valores para subtrair:n";
cin >> x >> y;
cout << subtrair(x, y);
cout << "Digite os valores para multiplicar:n";
cin >> x >> y;
cout << multiplicar(x, y);
cout << "Digite os valores para dividir:n";
cin >> x >> y;
cout << dividir(x, y);
}
Chamando uma função
double somar(double x, double y)
{
double resultado = x + y;
return resultado;
}
double subtrair(double x, double y)
{
double resultado = x - y;
return resultado;
}
double multiplicar(double x, double y)
{
double resultado = x * y;
return resultado;
}
double dividir(double x, double y)
{
double resultado = x / y;
return resultado;
}
Prof. Thomás da Costa Programação Estruturada II
39. Modularização e Funções
Funções
Chamando uma função:
Chamando a função “somar”
passando os parâmetros 10 e 15
Retornando o valor para a
variável “valor”
Protótipo da função
#include <iostream>
using namespace std;
double somar(double x, double y);
int main()
{
double valor;
valor = somar(10,15);
}
...
Prof. Thomás da Costa Programação Estruturada II
40. Modularização e Funções
Funções
Chamando uma função:
- Para executar uma função, devemos colocar o nome da função seguido dos
parâmetros
- Nos parâmetros podemos passar um valor especifico ou uma variável
- Devemos respeitar o tipo passado nos parâmetros das funções. Ex: se o
parâmetro for int, devemos passar um tipo int. Se for passado o tipo incorreto
no parâmetro, o programa não compila.
- Caso a função retorne algum valor, podemos atribuir diretamente a uma
variável
- Quando uma função não tem parâmetros, abrimos e fechamos parênteses
- void faz a função retornar nenhum valor
Prof. Thomás da Costa Programação Estruturada II
41. Modularização e Funções
Funções
Retorno da função:
Quando o tipo de retorno da função é diferente do tipo void, a função devolve
algum valor para alguma variável. Para efetuar este tipo de operação utilizamos a
palavra reservada return seguido de um valor ou uma variável.
Retorno da função
Retorno da função na
variável “resultado”
#include <iostream>
using namespace std;
int par_ou_impar(int numero);
int main()
{
int numero, resultado;
cout << "Digite um número:n";
cin >> numero;
resultado = par_ou_impar(numero);
if (resultado == 0)
cout << "Par";
else
cout << "Impar";
}
int par_ou_impar(int numero)
{
int valor = numero % 2;
return valor;
}
Prof. Thomás da Costa Programação Estruturada II
42. Modularização e Funções
Funções
Tipo void:
A palavra reservada void não efetua nenhum retorno para a função.
Retorno da função do
tipo void
Função não retorna um valor
#include <iostream>
using namespace std;
void imprime_idade(int idade);
int main()
{
int idade;
cout << "Digite a sua idade:n";
cin >> idade;
imprime_idade(idade);
}
void imprime_idade(int idade)
{
cout << "Sua idade é: " << idade;
}
Prof. Thomás da Costa Programação Estruturada II
43. Modularização e Funções
Funções
Usando return em uma função void:
O return em uma função void, interrompe a execução do código.
#include <iostream>
using namespace std;
void dividir(int x, int y);
int main()
{
int x, y;
cout << "Digite os valores para dividir:n";
cin >> x >> y;
dividir(x, y);
}
void dividir(int x, int y)
{
if (y == 0)
{
cout << "Não dividirás por zero";
return;
}
cout << "Valor da Divisão:" << x / y;
}
Não existe divisão por zero
Terminando a execução
da função com return
Este código não vai
ser executado
Prof. Thomás da Costa Programação Estruturada II
44. Modularização e Funções
Resumo:
- Possuem um nome
- Podem possuir um retorno ou não
- Tem parâmetros com tipo e nome, separados por virgulas
- A função tem um corpo, aonde é definido e escrito oque a função vai executar
- Tem um protótipo para definir a função
- São reutilizáveis
- Ajuda a deixar o código mais simples
- Funções quando usadas corretamente deixa muito mais fácil o entendimento
do programa
- Organização do código
- Retornam valores com a palavra reservada return
- void é tipo que não retorna valor na função
Funções
Prof. Thomás da Costa Programação Estruturada II
46. Modularização e Funções
Exemplo – Imprime na tela:
Funções
#include <iostream>
using namespace std;
void imprimir();
int main()
{
imprimir();
}
void imprimir()
{
char valor[10];
cout << "Digite algo:n";
gets(valor);
cout << valor;
}
Prof. Thomás da Costa Programação Estruturada II
47. Modularização e Funções
Exemplo – Quadrado:
Funções
#include <iostream>
using namespace std;
int quadrado(int x);
int main()
{
int x;
cout << "Digite um numero:n";
cin >> x;
cout << "Quadrado de " << x << " é " << quadrado(x);
}
int quadrado(int x)
{
return x * x;
}
Prof. Thomás da Costa Programação Estruturada II
48. Modularização e Funções
Exemplo – Conversor de Moedas:
Funções
#include <iostream>
using namespace std;
const double VALOR_DOLAR = 2.7;
void converte_real_dolar(double real);
int main()
{
double valor_real;
cout << "Valor em reais:";
cin >> valor_real;
converte_real_dolar(valor_real);
}
void converte_real_dolar(double real)
{
if (real < 0)
{
cout << "O valor não pode ser menor que zero";
return;
}
cout << "Valor convertido: " << real * VALOR_DOLAR;
}
Prof. Thomás da Costa Programação Estruturada II
49. Modularização e Funções
Exemplo – Calculadora:
Funções
#include <iostream>
using namespace std;
double somar(double x, double y);
double subtrair(double x, double y);
double multiplicar(double x, double y);
double dividir(double x, double y);
int main()
{
double x, y;
cout << "Digite os valores para somar:n";
cin >> x >> y;
cout << somar(x, y);
cout << "Digite os valores para subtrair:n";
cin >> x >> y;
cout << subtrair(x, y);
cout << "Digite os valores para multiplicar:n";
cin >> x >> y;
cout << multiplicar(x, y);
cout << "Digite os valores para dividir:n";
cin >> x >> y;
cout << dividir(x, y);
}
double somar(double x, double y)
{
double resultado = x + y;
return resultado;
}
double subtrair(double x, double y)
{
double resultado = x - y;
return resultado;
}
double multiplicar(double x, double y)
{
double resultado = x * y;
return resultado;
}
double dividir(double x, double y)
{
double resultado = x / y;
return resultado;
}
Prof. Thomás da Costa Programação Estruturada II
50. Modularização e Funções
O que é:
No caso da linguagem C++, escopo de variáveis é o ciclo de vida de um tipo de
dado e como ele pode ser acessado pelo programa principal e suas funções.
Escopo de Variáveis
Prof. Thomás da Costa Programação Estruturada II
51. Modularização e Funções
Exemplo:
Escopo de Variáveis
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
using namespace std;
int global = 0;
void escopo(int x);
int main()
{
int a = 1;
{
int b = 1;
cout << "Escopo mais interno: " << b << endl;
}
escopo(100);
cout << "Escopo local: " << a << endl;
}
void escopo(int x)
{
cout << "Escopo local: " << x << endl;
cout << "Escopo global: " << global << endl;
}
Variável global, ou seja, pode
ser acessada em qualquer
lugar do programa
Variável b pode ser acessada
somente neste trecho
Chaves definem
um escopo
52. Modularização e Funções
O que é:
É quando uma variável é passada como parâmetro de uma função, e seu valor
original não é alterado. Somente o valor da sua cópia pode ser alterado dentro
da função.
Parâmetros Por Valor
Prof. Thomás da Costa Programação Estruturada II
53. #include <iostream>
using namespace std;
void troca(int a, int b);
int main()
{
int a = 10;
int b = 20;
troca(a, b);
cout << "Valor de A e B não foi alterado:" << a <<
b << endl;
}
void troca(int a, int b)
{
a = b;
b = a + 100;
cout << "Valor de A e B: " << a << b << endl;
}
Modularização e Funções
Exemplo:
Parâmetros Por Valor
Prof. Thomás da Costa Programação Estruturada II
Variáveis a e b tem valor 10 e 20
Variáveis a e b continuam
com o mesmo valor 10 e 20
Trocamos o valor de a
com b dentro da função
54. Modularização e Funções
Parâmetros Por Referência
Prof. Thomás da Costa Programação Estruturada II
O que é:
É quando uma variável é passada como parâmetro de uma função, e seu valor
original pode ser alterado.
55. #include <iostream>
using namespace std;
void troca(int &a, int &b);
int main()
{
int a = 10;
int b = 20;
cout << "Valor de A e B original:" << a << "-" << b << endl;
troca(a, b);
cout << "Valor de A e B FOI alterado:" << a << "-" << b << endl;
}
void troca(int &a, int &b)
{
int temp;
temp = b;
b = a;
a = temp;
}
Modularização e Funções
Exemplo:
Parâmetros Por Referência
Prof. Thomás da Costa Programação Estruturada II
Variáveis a e b tem valor 10 e 20
Variáveis a e b mudam de
valor
Trocamos o valor de a
com b dentro da função
Referencia endereço de
memória
56. Modularização e Funções
Exemplo:
Parâmetros do Tipo String
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <string.h>
using namespace std;
int validar_senha(char *senha);
int main()
{
char senha[10];
cout << "Digite a senha:" << endl;
gets(senha);
validar_senha(senha);
}
int validar_senha(char *senha)
{
if (strcmp(senha, "entrar123") == 0)
{
cout << "Senha OK";
return 0;
} else {
cout << "Senha inválida";
return 1;
}
}
Passando uma string como
parâmetro devemos colocar o
sinal ( * )
57. Modularização e Funções
Exemplo:
Parâmetros do Tipo Vetor
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <string.h>
using namespace std;
void imprime_vetor(int *valores);
int main()
{
int valores[10] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
imprime_vetor(valores);
}
void imprime_vetor(int *valores)
{
for (int i=0;i<=9;i++)
{
cout << "valores[" << i << "] :" << valores[i] << endl;
}
}
Passando um vetor como
parâmetro devemos colocar o
sinal ( * )
CUIDADO: alterar o vetor
dentro da função, modifica o
valor que foi passado como
parâmetro
58. Modularização e Funções
Para pensar:
Podemos ter funções com o mesmo nome ?
Sim podemos !!!
Desde que as funções possuam parâmetros diferentes uma da outra. Essa técnica
é chamada de sobrecarga.
Sobrecarga de funções
Prof. Thomás da Costa Programação Estruturada II
Para acontecer a sobrecarga:
- Tipos de parâmetros diferentes
- Quantidades de parâmetros
59. Modularização e Funções
Exemplo:
Sobrecarga de funções
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <string.h>
using namespace std;
void imprime_vetor(char *valores);
void imprime_vetor(int *valores);
void imprime_vetor(int *valores, int tamanho);
int main()
{
int valores[10] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
char nome[10] = {'a','n','h','a','n','g','u','e','r','a'};
imprime_vetor(nome);
imprime_vetor(valores);
imprime_vetor(valores, 10);
}
Continua ->
Funções com o mesmo nome e
parâmetros diferentes
60. Modularização e Funções
Exemplo - Continuação:
Sobrecarga de funções
Prof. Thomás da Costa Programação Estruturada II
void imprime_vetor(char *valores)
{
cout << "void imprime_vetor(char *valores)" << endl;
for (int i=0;i<=9;i++)
{
cout << "valores[" << i << "] :" << valores[i] << endl;
}
}
void imprime_vetor(int *valores)
{
cout << "void imprime_vetor(int *valores)" << endl;
for (int i=0;i<=9;i++)
{
cout << "valores[" << i << "] :" << valores[i] << endl;
}
}
void imprime_vetor(int *valores, int tamanho)
{
cout << "void imprime_vetor(int *valores, int tamanho)" << endl;
for (int i=0;i<tamanho;i++)
{
cout << "valores[" << i << "] :" << valores[i] << endl;
}
}
61. Modularização e Funções
Exemplo:
Valores Default
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
using namespace std;
double media(double b1 = 0, double b2 = 0);
int main()
{
cout << "Media Default:" << media() << endl;
cout << "Media Aluno:" << media(6.5, 6.5) << endl;
}
double media(double b1, double b2)
{
return (b1 + b2) / 2;
}
Valores pré-definidos na
função é chamado de valores
default
62. Modularização e Funções
Desenvolvendo uma Biblioteca !!!:
Vamos criar uma biblioteca para ser utilizada em todos os nossos programas. A
nossa biblioteca será chamada pela diretiva #include, como todas as outras do
C++.
Para criar um biblioteca:
- Criar um projeto no Dev-C++
- Criar um arquivo .h com os protótipos das funções
- Criar um arquivo .cpp com as definições das funções
Bibliotecas
Prof. Thomás da Costa Programação Estruturada II
63. Modularização e Funções
Vamos criar uma biblioteca matemática:
Criando um projeto do Dev-C++:
- File -> New Project
- Console Application
- Colocar em Name (nome do projeto) matematica
Bibliotecas
Prof. Thomás da Costa Programação Estruturada II
64. Modularização e Funções
Vamos criar uma biblioteca matemática:
- Criar arquivo .h
- Criar arquivo .cpp
Bibliotecas
Prof. Thomás da Costa Programação Estruturada II
Arquivos da biblioteca .h e .cpp
65. namespace matematica
{
double somar(double x, double y);
double subtrair(double x, double y);
double multiplicar(double x, double y);
double dividir(double x, double y);
}
Modularização e Funções
Arquivo .h:
Bibliotecas
Prof. Thomás da Costa Programação Estruturada II
Namespace da biblioteca
Os namespace´s servem para identificar uma
biblioteca, tornando única dentro da aplicação
e não entrar em conflito com outras
bibliotecas
66. #include <iostream>
#include "matematica.h"
using namespace std;
namespace matematica
{
double somar(double x, double y)
{
return x + y;
}
double subtrair(double x, double y)
{
return x - y;
}
double multiplicar(double x, double y)
{
return x * y;
}
double dividir(double x, double y)
{
return x / y;
}
}
Modularização e Funções
Arquivo .cpp:
Bibliotecas
Prof. Thomás da Costa Programação Estruturada II
Implementações das funções
Namespace da biblioteca
67. #include <iostream>
#include "matematica.h"
using namespace matematica;
using namespace std;
int main() {
cout << "Somar:" << somar(2,2) << endl;
cout << "Subtrair:" << subtrair(2,2) << endl;
cout << "Multiplicar:" << multiplicar(2,2) << endl;
cout << "Dividir:" << dividir(2,2) << endl;
}
Modularização e Funções
Usando a biblioteca:
Bibliotecas
Prof. Thomás da Costa Programação Estruturada II
Chamando as funções
Namespace da biblioteca
Incluindo a biblioteca no programa
68. Estruturas, Uniões e Enumeração
ESTRUTURAS, UNIÕES E ENUMERAÇÃO
Prof. Thomás da Costa Programação Estruturada II
69. Estruturas, Uniões e Enumeração
O que é:
É um conjunto de variáveis que representam características de um determinado
domínio ou de um tipo. A estrutura pode definir uma entidade e possui grande
semelhança com registros de banco de dados. O agrupamento de variáveis pode
ser de qualquer tipo, sendo denominado de membro da estrutura.
Estruturas
Prof. Thomás da Costa Programação Estruturada II
70. Estruturas, Uniões e Enumeração
Exemplo:
Quais são as informações de um Aluno para a Faculdade?
- Nome
- Matrícula
- Série
- Turma
- Curso
No exemplo acima temos a estrutura Aluno que contém as informações ou as
características de um aluno. Muito semelhante a um registro de banco de dados.
Podemos dizer que em uma estrutura, estamos armazenando informações
agrupadas logicamente.
Estruturas
Prof. Thomás da Costa Programação Estruturada II
71. Estruturas, Uniões e Enumeração
Mais um exemplo:
Quais as informações de um Funcionário para uma Empresa?
- Nome
- Dados Pessoais
- Data de Admissão
- Cargo
- Salário
- Setor/Área de Atuação
Estruturas
Prof. Thomás da Costa Programação Estruturada II
Vamos ver como fazer uma estrutura em
C/C++ !!!
72. Estruturas, Uniões e Enumeração
Estruturas em C/C++:
Estruturas
Prof. Thomás da Costa Programação Estruturada II
struct aluno
{
char nome[255];
int ra;
int serie;
int turma;
char curso[100];
};
Nome da estrutura
Palavra reservada
que identifica uma
estrutura
Membros da estrutura
Chaves definem o início
e o fim da estrutura
Termina com ponto e
vírgula
73. Estruturas, Uniões e Enumeração
Memória:
Uma estrutura armazena vários tipos de dados e ocupa a memória de acordo com
a quantidade de membros declarados na estrutura.
Estruturas
Prof. Thomás da Costa Programação Estruturada II
struct aluno
{
char nome[255];
int ra;
int serie;
int turma;
char curso[100];
};
Membro Bytes
char nome[255] 255
int ra 4
int serie 4
int turma 4
char curso[100] 100
TOTAL: 367
74. Estruturas, Uniões e Enumeração
Uma curiosidade:
Para saber o tamanho de um tipo de dado ou variável usamos o operador sizeof.
Os tamanhos podem variar de computador, compilador e sistema operacional.
Estruturas
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
using namespace std;
int main()
{
cout << "Tam. do CHAR:" << sizeof(char) << endl;
cout << "Tam. do INT:" << sizeof(int) << endl;
cout << "Tam. do DOUBLE:" << sizeof(double) << endl;
cout << "Tam. do FLOAT:" << sizeof(float) << endl;
}
75. Estruturas, Uniões e Enumeração
Estruturas
Prof. Thomás da Costa Programação Estruturada II
struct aluno
{
char nome[255];
int ra;
int serie;
int turma;
char curso[100];
} aluno_anhanguera;
struct aluno aluno_tecnologia;
aluno aluno_curso;
Declarando uma variável do tipo Estrutura:
Existem 3 formas de declarar uma variável de estrutura:
76. Estruturas, Uniões e Enumeração
Acessando membros de uma estrutura:
Para acessar um membro de uma estrutura utilizamos o operador ponto (.)
Estruturas
Prof. Thomás da Costa Programação Estruturada II
...
struct aluno
{
char nome[255];
int ra;
int serie;
int turma;
char curso[100];
} aluno_anhanguera;
...
int main()
{
cout << aluno_anhanguera.nome << endl;
}
Acessando um membro
O membro “nome” da estrutura
será impresso na tela
77. Estruturas, Uniões e Enumeração
Atribuindo valores para membros de uma função:
Estruturas
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
using namespace std;
struct demonstracao
{
char caracter;
double valor1;
float valor2;
int valor3;
} demo;
int main()
{
demo.caracter = 'A';
demo.valor1 = 3.2;
demo.valor2 = 6.7;
demo.valor3 = 45;
cout << demo.caracter << endl;
cout << demo.valor1 << endl;
cout << demo.valor2 << endl;
cout << demo.valor3 << endl;
}
Atribuição de valores
78. Estruturas, Uniões e Enumeração
Atribuindo valores para membros de uma função:
Estruturas
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <string.h>
using namespace std;
struct demonstracao
{
char string[100];
int vetor_inteiro[10];
double vetor_double[5];
} demo;
int main()
{
strcpy(demo.string, "Valor da String:");
demo.vetor_inteiro[0] = 1;
demo.vetor_inteiro[2] = 2;
demo.vetor_double[4] = 5.6;
cout << demo.string << endl;
cout << demo.vetor_inteiro[0] << endl;
cout << demo.vetor_inteiro[2] << endl;
cout << demo.vetor_double[4] << endl;
}
Vetor de char usar
strcpy
Atribuição de valores
em vetores
79. Estruturas, Uniões e Enumeração
Atribuindo valores para membros de uma função:
Estruturas
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <string.h>
using namespace std;
struct demonstracao
{
char string[100];
char caracter;
int valor_inteiro;
double valor_double;
} demo;
int main()
{
cout << "Digite o valor da string:" << endl;
gets(demo.string);
cout << "Digite os valores:" << endl;
cin >> demo.caracter >> demo.valor_inteiro
>> demo.valor_double;
cout << "Valores digitados:" << demo.string
<< "," << demo.caracter
<< "," << demo.valor_inteiro
<< "," << demo.valor_double << endl;
}
O cin funciona da mesma forma em
um membro de uma estrutura
O gets funciona da mesma forma em
um membro de uma estrutura
80. Estruturas, Uniões e Enumeração
Resumo:
- É definida pela palavra struct
- Possuem um nome
- Representa algum domínio, tipo ou uma entidade
- Os tipos de uma estrutura são agrupadas logicamente
- Composta de membros que são tipos de variáveis (int, double, float, char)
- Seus membros são acessados utilizando o ponto (.)
- Para atribuir valores (int, double, char e etc), utilizamos o operador igual (=),
idêntico a atribuição de uma variável
- Utilizamos o strcpy para atribuir um valor para um vetor de char
- Os comandos cin e gets funcionam da mesma forma para os membros de uma
estrutura
- Vetores também são acessado da mesma forma, através de seus índices
Estruturas
Prof. Thomás da Costa Programação Estruturada II
81. Estruturas, Uniões e Enumeração
Passando membros de uma estrutura como parâmetro:
Estruturas em Funções
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <string.h>
using namespace std;
struct aluno
{
char nome[100];
int ra;
} aluno_tecnologia;
void imprimir_aluno(char *nome, int ra);
int main()
{
cout << "Digite o nome do aluno:";
gets(aluno_tecnologia.nome);
cout << "Digite o RA do aluno:";
cin >> aluno_tecnologia.ra;
imprimir_aluno(aluno_tecnologia.nome,
aluno_tecnologia.ra);
}
void imprimir_aluno(char *nome, int ra)
{
cout << nome << endl;
cout << ra << endl;
}
Passamos os membros como
parâmetro para a função
82. Estruturas, Uniões e Enumeração
Parâmetros por referência:
Estruturas em Funções
Prof. Thomás da Costa Programação Estruturada II
...
void troca_aluno(char *nome, int &ra);
int main()
{
...
troca_aluno(aluno_tecnologia.nome,
aluno_tecnologia.ra);
cout << aluno_tecnologia.nome;
cout << aluno_tecnologia.ra;
}
void troca_aluno(char *nome, int &ra)
{
strcpy(nome, "Novo Aluno");
ra = 123456;
}
* e o & definem
também, a passagem
por referência.
Trocando os valores
da estrutura
83. Estruturas, Uniões e Enumeração
Estrutura como parâmetro (Por valor):
Podemos passar uma estrutura inteira como parâmetro de uma função. Os
parâmetros podem ser também por valor ou por referência
Estruturas em Funções
Prof. Thomás da Costa Programação Estruturada II
...
void imprimir_aluno(struct aluno alu);
int main()
{
...
imprimir_aluno(aluno_tecnologia);
}
void imprimir_aluno(struct aluno alu)
{
cout << alu.nome << endl;
cout << alu.ra << endl;
}
Definindo a passagem
de uma estrutura
como parâmetro
Passando a estrutura
A palavra struct não é
obrigatória na passagem
do parâmetro
84. Estruturas, Uniões e Enumeração
Estrutura como parâmetro (Por referência):
Estruturas em Funções
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <string.h>
using namespace std;
struct aluno
{
char nome[100];
int ra;
};
void ler_aluno(struct aluno &alu);
int main()
{
struct aluno aluno_tecnologia;
ler_aluno(aluno_tecnologia);
cout << aluno_tecnologia.nome << endl;
cout << aluno_tecnologia.ra << endl;
}
void ler_aluno(struct aluno &alu)
{
cout << "Digite o nome do aluno:" << endl;
gets(alu.nome);
cout << "Digite o RA do aluno:" << endl;
cin >> alu.ra;
}
& define, a passagem por
referência.
85. Estruturas, Uniões e Enumeração
Vetores de Estruturas:
Estruturas
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <string.h>
using namespace std;
struct aluno
{
char nome[100];
int ra;
};
int main()
{
struct aluno alunos[10];
cout << "Digite o nome do 1º aluno:" << endl;
gets(alunos[0].nome);
cout << "Nome do 1º aluno:"
<< alunos[0].nome << endl;
}
Declarando um vetor de
estruturasUtilizamos índices do
vetor para mostrar o
valor de um membro
da estrutura
86. Estruturas, Uniões e Enumeração
Estruturas dentro de estruturas:
Estruturas
Prof. Thomás da Costa Programação Estruturada II
struct curso
{
char nome_curso[255];
};
struct aluno
{
char nome[100];
int ra;
struct curso cur;
};
int main()
{
...
cout << alu.nome << endl;
cout << alu.cur.nome_curso << endl;
}
Declarando a estrutura
curso dentro de aluno
Mostrando o nome_curso
da estrutura curso
declarada em aluno
87. Estruturas, Uniões e Enumeração
Prof. Thomás da Costa Programação Estruturada II
89. Estruturas, Uniões e Enumeração
Exemplo (Aumentar Salário):
Estruturas
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <string.h>
using namespace std;
struct funcionario
{
char nome[255];
char cargo[255];
double salario;
int idade;
};
void aumentar_salario(double &salario,
int percen);
int main()
{
struct funcionario func;
cout << "Digite o salário:" << endl;
cin >> func.salario;
aumentar_salario(func.salario, 20);
cout << "Novo salário:" << func.salario;
}
void aumentar_salario(double &salario,
int percen)
{
double val = (percen / 100.0);
salario = salario * (1 + val);
}
Todo mundo gosta desse exemplo !!!
90. Estruturas, Uniões e Enumeração
O que é:
É um tipo de estrutura, aonde os membros compartilham a mesma posição de
memória, criando código portável independente de máquina. Em sua forma geral,
as uniões possuem algumas características das estruturas.
Uniões
Prof. Thomás da Costa Programação Estruturada II
91. Estruturas, Uniões e Enumeração
Como funciona:
- As uniões utilizam o mesmo espaço de memória para todas as variáveis
- Quando declaradas, o compilador cria um espaço de memória grande o
suficiente para guardar o maior tipo de variável
- Como o espaço é compartilhado entre os membros da união, precisamos nos
preocupar com as informações que estão sendo gravadas
- As uniões possuem algumas características das estruturas
- A forma de acessar os membros e atribuir valores em um união, são iguais aos
mostrados em estruturas
Uniões
Prof. Thomás da Costa Programação Estruturada II
Vamos ver como fazer uma união
em C/C++ !!!
92. Estruturas, Uniões e Enumeração
Uniões em C/C++:
Uniões
Prof. Thomás da Costa Programação Estruturada II
Nome da união
Palavra reservada
que identifica uma
união Membros da união
Chaves definem o início
e o fim da união
Termina com ponto e
vírgula
union valor
{
int valor_1;
float valor_2;
double valor_3;
char valor_4;
};
93. Estruturas, Uniões e Enumeração
Memória:
A união tem o tamanho do maior membro declarado, diferente da estrutura que
possui o tamanho equivalente a soma de todos os membros. No exemplo abaixo a
união possui 8 bytes.
Uniões
Prof. Thomás da Costa Programação Estruturada II
union valor
{
int valor_1;
float valor_2;
double valor_3;
char valor_4;
};
Membro Bytes
int valor_1 4
float valor_2 4
double valor_3 8
char valor_4 1
TOTAL: 8
94. Estruturas, Uniões e Enumeração
Exemplo:
Uniões
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
using namespace std;
union valor_union
{
int valor_1;
float valor_2;
double valor_3;
char valor_4;
} valor;
void imprimir();
int main()
{
cin >> valor.valor_1;
imprimir();
cin >> valor.valor_2;
imprimir();
cin >> valor.valor_3;
imprimir();
cin >> valor.valor_4;
imprimir();
}
void imprimir()
{
cout << "Valores:" << endl;
cout << valor.valor_1 << endl;
cout << valor.valor_2 << endl;
cout << valor.valor_3 << endl;
cout << valor.valor_4 << endl;
}
95. Estruturas, Uniões e Enumeração
O que é:
É um tipo de dado, que possui um conjunto de números inteiros constantes, que
definem os possíveis valores válidos para a enumeração. Muito semelhante a um
vetor de inteiro.
Enumeração
Prof. Thomás da Costa Programação Estruturada II
96. Estruturas, Uniões e Enumeração
Vamos pensar:
Quais são as nossas despesas mensais?
- Aluguel
- Faculdade
- Celular
- Internet
- Conta de Água
- Conta de Luz
- Carro
Essas informações definem uma enumeração chamada despesas. Podemos criar
um programa, que efetue o cálculo das despesas mensais, de acordo com o salário
digitado do usuário.
Essa enumeração define um tipo ou uma faixa de tipos constantes que podemos
utilizar no nosso programa.
Enumeração
Prof. Thomás da Costa Programação Estruturada II
97. Estruturas, Uniões e Enumeração
Vamos pensar:
Quais são as cores de uma caixa de lápis de cor?
- Azul
- Vermelho
- Amarelo
- Verde
- Preto
- Branco
- Laranja
Essas informações definem uma enumeração chamada cores.
Enumeração
Prof. Thomás da Costa Programação Estruturada II
Vamos ver como fazer uma enumeração em C/C++ !!!
98. Estruturas, Uniões e Enumeração
Enumerações em C/C++:
Enumeração
Prof. Thomás da Costa Programação Estruturada II
Nome do enum
Palavra reservada
que identifica um
enum
Valores inteiros de um enum
Chaves definem o início
e o fim do enum
Termina com ponto e
vírgula
enum despesas
{
ALUGUEL,
FACULDADE,
CELULAR,
INTERNET,
CONTA_AGUA,
CONTA_LUZ
};
99. Estruturas, Uniões e Enumeração
Exemplo:
Enumeração
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
using namespace std;
enum despesas
{
ALUGUEL,
FACULDADE
};
int main()
{
int valor;
cout << "Digite o tipo da despesa:" << endl;
cin >> valor;
switch (valor) {
case ALUGUEL: {
cout << "Aluguel";
break;
}
case FACULDADE: {
cout << "Faculdade";
break;
}
default: {
cout << "Não encontrado";
break;
}
}
}
No enum os valores dos membros
começam com 0 e segue a sequência
numérica
100. Estruturas, Uniões e Enumeração
Exemplo:
Vamos modificar o programa feito no laboratório para utilizar enumeração.
(Exercício 4 do nível básico).
Enumeração
Prof. Thomás da Costa Programação Estruturada II
...
enum opcoes
{
INCLUIR = 1,
LISTAR = 2,
SAIR = 0
};
...
if (opcao == INCLUIR)
{
cout << "Digite o produto:" << endl;
cin >> produto;
incluir_produto(produto);
}
if (opcao == LISTAR)
listar_produto();
if (opcao == SAIR)
break;
system("cls");
...
Podemos atribuir valores fixos
para o enum
101. Estruturas, Uniões e Enumeração
Definição:
Quando precisamos definir novos nomes a determinados tipos de dados,
utilizamos o operador typedef. Não criamos um novo tipo de variável, somente
um “apelido” para um tipo existente.
Tipos definidos pelo Usuário
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <strings.h>
using namespace std;
typedef char valores[100];
int main()
{
valores val;
strcpy(val, "Programação Estruturada II");
cout << "Tipo do usuário:" << val;
}
103. Arquivos
Bem conhecido no nosso dia-a-dia:
Todos os dias no nosso trabalho ou em casa utilizamos arquivos para armazenar
informações tais como: imagem, texto, trabalho de faculdade, relatórios, planilhas
de gastos e etc. Até esse ponto do curso, todas as informações eram armazenadas
na memória, ou seja, quando um programa terminava não existia nenhum
processo de armazenamento de dados.
Vamos aprender a armazenar informações em arquivos textos ou de dados !!!
Arquivos
Prof. Thomás da Costa Programação Estruturada II
104. Arquivos
Tipos de Arquivos:
Texto: armazena somente texto e caracteres. Normalmente possuem extensão txt
Binário: arquivos que podem armazenar textos, imagens, planilhas e outros tipos
de informações. Algumas extensões conhecidas: pdf, doc, xls, gif
Arquivos
Prof. Thomás da Costa Programação Estruturada II
105. Arquivos
Criando arquivos textos em C++:
Arquivos
Prof. Thomás da Costa Programação Estruturada II
#include <fstream>
...
ofstream ofs;
ofs.open("ola_mundo.txt", ios::out);
Include da biblioteca de arquivos
Variável do arquivo
Nome do arquivo
Formato de abertura do arquivo
106. Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <fstream>
#include <strings.h>
using namespace std;
void gravar_arquivo();
int main()
{
gravar_arquivo();
}
void gravar_arquivo()
{
string valor;
valor = "Ola Mundo";
ofstream ofs;
ofs.open("ola_mundo.txt", ios::out);
ofs << valor;
ofs.close();
}
Exemplo 1
Grava um texto no arquivo
O tipo string é semelhante a um vetor de char,
ou seja, armazena um conjunto de caracteres
107. Arquivos
Lendo arquivos textos em C++:
Arquivos
Prof. Thomás da Costa Programação Estruturada II
#include <fstream>
...
ifstream ifs;
ifs.open("ola_mundo.txt", ios::in);
Include da biblioteca de arquivos
Variável do arquivo
Nome do arquivo
Formato de abertura do arquivo
108. Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <fstream>
#include <strings.h>
using namespace std;
void ler_arquivo();
int main()
{
ler_arquivo();
}
void ler_arquivo()
{
string valor;
ifstream ifs;
ifs.open("ola_mundo.txt", ios::in);
if (!ifs.is_open())
{
cout << "Não foi possivel abrir o arquivo" << endl;
return;
}
getline(ifs, valor);
cout << "Conteúdo do Arquivo:" << valor << endl;
ifs.close();
}
Exemplo 2
Efetua a leitura de uma
linha no arquivo
109. Arquivos
Lembrete:
Sempre que um arquivo for aberto para leitura ou escrita, o mesmo deve ser
fechado, para que possa ser utilizado por outros programas e não ocupar recursos
do sistema operacional.
Arquivos
Prof. Thomás da Costa Programação Estruturada II
Utilizar o comando close() dos objetos
ofstream e ifstream !!!
110. Arquivos
Novos tipos e comandos:
string: novo tipo de variável, semelhante a um vetor de char
getline: efetua a leitura de uma linha de um arquivo
is_open: verifica se o arquivo foi aberto ou criado corretamente no disco. Exemplo
de problemas: falta de espaço em disco, diretório não existente e etc
Arquivos
Prof. Thomás da Costa Programação Estruturada II
111. Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <fstream>
#include <strings.h>
using namespace std;
void gravar_arquivo();
int main()
{
gravar_arquivo();
}
void gravar_arquivo()
{
int valor_1;
double valor_2;
float valor_3;
char valor_4;
cin >> valor_1;
cin >> valor_2;
cin >> valor_3;
cin >> valor_4;
ofstream ofs;
ofs.open("numeros.txt", ios::out);
ofs << valor_1 << endl;
ofs << valor_2 << endl;
ofs << valor_3 << endl;
ofs << valor_4 << endl;
ofs.close();
}
Exemplo 3
Lendo valores a partir do teclado
Gravando os valores sequencialmente
112. #include <iostream>
#include <fstream>
#include <strings.h>
using namespace std;
void ler_arquivo();
int main()
{
ler_arquivo();
}
Prof. Thomás da Costa Programação Estruturada II
void ler_arquivo()
{
int valor_1;
double valor_2;
float valor_3;
char valor_4;
ifstream ifs;
ifs.open("numeros.txt", ios::in);
if (!ifs.is_open())
{
cout << "Não foi possivel abrir o arquivo" << endl;
return;
}
ifs >> valor_1;
ifs >> valor_2;
ifs >> valor_3;
ifs >> valor_4;
cout << "Valores do arquivo:" << valor_1 << ","
<< valor_2 << "," << valor_3 << "," << valor_4;
ifs.close();
}
Exemplo 4
Lendo os valores sequencialmente
113. Arquivos
Formas de abertura de um arquivo:
Quando trabalhamos com arquivos, existem várias formas de leitura e escrita.
Podemos abrir o arquivo somente para leitura, escrita, escrita/leitura e etc. Para
escolher a forma de trabalhar com o arquivo, passamos parâmetros na função
open do ofstream ou do ifstream conforme a tabela abaixo:
Arquivos
Prof. Thomás da Costa Programação Estruturada II
Parâmetro Descrição
ios::in Efetua operação de leitura de arquivo (Sempre usar no ifstream)
ios::out Efetua operação de escrita de arquivo (Sempre usar no ofstream)
ios::binary Cria um arquivo binário
ios::app Insere valores no fim do arquivo
ios::trunc Apaga o conteúdo do arquivo e substitui por um novo
114. Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <fstream>
#include <strings.h>
using namespace std;
void gravar_fim_arquivo();
int main()
{
gravar_fim_arquivo();
}
void gravar_fim_arquivo()
{
string valor;
valor = "Nova linha no arquivo";
ofstream ofs;
ofs.open("arquivo_linhas.txt", ios::out | ios::app);
ofs << valor << endl;
ofs.close();
}
Exemplo 5
Abre o arquivo para escrita e
insere valores no final do arquivo
115. Arquivos
Lendo um arquivo com várias linhas:
Normalmente um arquivo texto possui várias linhas de caracteres. Quando
desenvolvemos um programa para ler um arquivo, não temos ideia do seu
tamanho. Para efetuarmos a leitura do arquivo até o seu fim, utilizamos o
comando getline dentro de uma instrução while.
Arquivos
Prof. Thomás da Costa Programação Estruturada II
O comando getline busca sempre o
fim de linha
116. Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <fstream>
#include <strings.h>
using namespace std;
void gravar_arquivo();
int main()
{
gravar_arquivo();
}
void gravar_arquivo()
{
string valor;
ofstream ofs;
ofs.open("arquivo_linhas.txt", ios::out);
valor = "O que são funções:";
ofs << valor << endl;
valor = "São rotinas que tem como objetivo, "
"executar trechos de códigos de forma modular, "
"melhorando a organização do programa e evitando repetição de
código.";
ofs << valor << endl;
valor = "As funções são reutilizáveis dentro de um programa.";
ofs << valor << endl;
ofs.close();
}
Exemplo 6
Criando um arquivo com várias
linhas. No nosso caso, 3 linhas.
117. Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
#include <fstream>
#include <strings.h>
using namespace std;
void ler_arquivo();
int main()
{
ler_arquivo();
}
void ler_arquivo()
{
string linha;
ifstream ifs;
ifs.open("arquivo_linhas.txt", ios::in);
if (!ifs.is_open())
{
cout << "Não foi possivel abrir o arquivo" << endl;
return;
}
while (getline(ifs, linha))
{
cout << linha << endl;
}
ifs.close();
}
Exemplo 7
Utilizando getline para efetuar a leitura de
uma linha. Enquanto existir linha no
arquivo, a leitura será efetuada
118. Arquivos
Gravando estruturas em arquivo:
Até agora vimos como gravar informações no formato texto.
Neste ponto da matéria, iremos aprender a gravar um estrutura dentro de um
arquivo. A estrutura é gravado em um arquivo no formato binário
Para isso vamos aprender uma nova forma de trabalhar com arquivo. Essa nova
forma, podemos gravar e ler informações utilizando apenas um tipo de variável,
sem precisar usar o ofstream e o ifstream
Arquivos
Prof. Thomás da Costa Programação Estruturada II
Vamos ver a nova forma de gravação em arquivos !!!
119. #include <fstream>
...
fstream fst;
fst.open("registros.dat",
ios::in | ios::out | ios::app | ios::binary);
Arquivos
Escrevendo/Lendo arquivos textos e binários em C++:
Arquivos
Prof. Thomás da Costa Programação Estruturada II
Include da biblioteca de arquivos
Variável do arquivo
Nome do arquivo
Formato de abertura do arquivo
120. fst.write((char *)&alu, sizeof(alu));
Arquivos
Gravando uma estrutura em um arquivo:
Arquivos
Prof. Thomás da Costa Programação Estruturada II
Comando para gravação
“Cast” da estrutura para char
Tamanho da estrutura que será gravada
121. Prof. Thomás da Costa Programação Estruturada II
Exemplo 8
#include <iostream>
#include <fstream>
#include <strings.h>
#include <limits>
using namespace std;
struct alunos
{
long id;
char nome[255];
char ra[30];
int idade;
};
void gravar_arquivo_registros();
int main()
{
gravar_arquivo_registros();
}
void gravar_arquivo_registros()
{
alunos alu;
cout << "Digite o nome do aluno:";
gets(alu.nome);
cout << "Digite o RA do aluno:";
gets(alu.ra);
cout << "Digite a idade do aluno:";
cin >> alu.idade;
fstream fst;
fst.open("registros.dat",
ios::in | ios::out | ios::app | ios::binary);
if (!fst.is_open())
{
cout << "Não foi possivel abrir o arquivo"
<< endl;
return;
}
fst.write((char *)&alu, sizeof(alu));
fst.close();
}
Gravando uma estrutura no
arquivo
122. fst.read((char *)&alu,sizeof(alu))
Arquivos
Lendo uma estrutura em um arquivo:
Arquivos
Prof. Thomás da Costa Programação Estruturada II
Comando para leitura
“Cast” da estrutura para char
Tamanho da estrutura que será lida
123. Prof. Thomás da Costa Programação Estruturada II
Exemplo 9
#include <iostream>
#include <fstream>
#include <strings.h>
#include <limits>
using namespace std;
struct alunos
{
long id;
char nome[255];
char ra[30];
int idade;
};
void ler_arquivo_registros();
int main()
{
ler_arquivo_registros();
}
void ler_arquivo_registros()
{
alunos alu;
fstream fst;
fst.open("registros.dat",
ios::in | ios::out | ios::app | ios::binary);
if (!fst.is_open())
{
cout << "Não foi possivel abrir o arquivo";
return;
}
while (fst.read((char *)&alu,sizeof(alu)))
{
cout << "************************" << endl;
cout << "Nome:" << alu.nome << endl;
cout << "RA:" << alu.ra << endl;
cout << "Idade:" << alu.idade << endl;
}
fst.close();
}
Lendo uma estrutura do
arquivo
124. Arquivos
Resumo:
- Existem dois formatos de arquivos: texto e binário
- Utilizamos o tipo ofstream para escrita em um arquivo
- Utilizamos o tipo ifstream para leitura em um arquivo
- Podemos gravar uma estrutura em um arquivo
- O tipo fstream é utilizado para escrita e leitura de arquivos
- Devemos sempre fechar o arquivo com o close do tipo específico do arquivo
- O tipo string é semelhante a um vetor de char
- O comando getline efetua a leitura de uma linha em um arquivo texto
- O is_open tem como finalidade, indicar se o arquivo foi aberto ou criado
corretamente
- Para efetuar a leitura de um arquivo com várias linhas utilizamos o getline
dentro de laço até o final do arquivo
Arquivos
Prof. Thomás da Costa Programação Estruturada II
126. Ponteiros
O que é:
É um tipo de variável que armazena um endereço de memoria referente a uma
outra variável. O ponteiro não armazena diretamente um valor como os outros
tipos em C++.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
127. Ponteiros
Mais detalhes:
- O entendimento de ponteiros é complexo
- São utilizados quando desejamos passar vetores como parâmetros da função
- É utilizado em passagem de parâmetros por referência
- Quando desejamos alocar e desalocar memória manualmente
- Em vetores do tipo char
- Criar estruturas complexas, como lista encadeadas e árvores binárias
- Atuar com desenvolvimento de aplicações complexas
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
128. Ponteiros
Operadores:
Para operação com ponteiros, utilizamos dois operadores unários:
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Operador Descrição
* Utilizado para declarar um ponteiro e para retornar o valor
& Utilizado para retornar o endereço de memória da variável
Vamos ver como declarar uma variável do tipo ponteiro !!!
129. Ponteiros
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Declarando uma variável do tipo ponteiro:
int *ptr;
Tipo da variável
Nome da variável
Operador unário
130. Prof. Thomás da Costa Programação Estruturada II
Exemplo 1#include <iostream>
using namespace std;
int main()
{
int *ptr;
cout << ptr << endl;
}
Declarando um ponteiro
Exibe o endereço da variável, neste caso,
nenhum endereço foi atribuído
131. Ponteiros
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Declaração e atribuição de ponteiros:
Variável ponteiro
Atribuindo o endereço de
memória
int *ptr;
int valor;
valor = 1500;
ptr = &valor;
132. Prof. Thomás da Costa Programação Estruturada II
Exemplo 2
#include <iostream>
using namespace std;
int main()
{
int valor;
int *ptr;
valor = 1500;
ptr = &valor;
cout << ptr << endl;
cout << *ptr << endl;
}
ptrvalor
0x23fe480x23fe44
0x23fe480x23fe44 0x23fe441500
133. Ponteiros
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Mais detalhes:
- Ponteiro armazena o endereço de memória
- O operador & mostra o endereço da variável
- O operador * é utilizado na declaração do ponteiro
- Exibindo o valor de um ponteiro com cout é mostrado o
endereço referenciado
- Utilizando o operador * seguido pelo nome da variável
de ponteiro é exibido o valor atribuído no endereço de
memória referente.
Vamos ver mais um exemplo !!!
134. Prof. Thomás da Costa Programação Estruturada II
Exemplo 3
#include <iostream>
using namespace std;
int main()
{
int valor;
int *ptr;
int total;
valor = 1600;
ptr = &valor;
total = *ptr;
cout << *ptr << endl;
cout << total << endl;
}
ptrvalor
0x23fe480x23fe44
total
0x23fe40
0x23fe480x23fe44 0x23fe401600 0x23fe44 1600
135. Ponteiros
Importante:
A atribuição de valores para ponteiros, deve ser do mesmo tipo. Quando as
variáveis são de tipos diferentes, vamos ter um erro de compilação.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
136. Prof. Thomás da Costa Programação Estruturada II
Exemplo 4
#include <iostream>
using namespace std;
int main()
{
// PROGRAMA COM ERRO NAO COMPILA !!!!
int *ptr_inteiro;
double valor;
valor = 345.76;
ptr_inteiro = &valor;
cout << *ptr_inteiro << endl;
}
ERRO !!!
137. Ponteiros
Conversão de valores:
Para atribuir ponteiros de tipos diferentes, utilizamos um conceito chamado cast.
O cast de variáveis ocorre em tipos similares. Neste processo as variáveis de um
tipo são convertido em outro tipo. Muitas vezes esta conversão não ocorre 100%
conforme o esperado.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
138. Ponteiros
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Conversão de valores:
int *ptr_inteiro;
double valor;
ptr_inteiro = (int *)&valor;
Conversão de valores
139. Ponteiros
Conversão de valores:
Temos um pequeno problema quando existe a conversão de ponteiros de tipos
diferentes. Vamos ver no próximo exemplo.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
140. Prof. Thomás da Costa Programação Estruturada II
Exemplo 5
#include <iostream>
using namespace std;
int main()
{
double valor;
int *ptr_inteiro;
valor = 345.76;
ptr_inteiro = (int *)&valor;
cout << *ptr_inteiro << endl;
}
ptr_inteirovalor
0x23fe480x23fe40
0x23fe40345.76 0x23fe480x23fe40
Valor exibido:
-171798692
Valor incorreto exibido pelo ponteiro !!!
141. Prof. Thomás da Costa Programação Estruturada II
Exemplo 6
#include <iostream>
using namespace std;
int main()
{
int *ptr_inteiro;
double valor_1;
double valor_2;
valor_1 = 345.76;
ptr_inteiro = (int *)&valor_1;
valor_2 = *ptr_inteiro;
cout << valor_1 << endl;
cout << *ptr_inteiro << endl;
cout << valor_2 << endl;
}
São exibidos valores errados
Conversão não funciona completamente
142. Ponteiros
Atribuição de valores:
Podemos atribuir um valor diretamente para um ponteiro. Para isso utilizamos o
operador * antes do nome da variável do tipo ponteiro.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
*ptr = 999;
Variável do tipo ponteiro
Atribuindo um valor
143. Prof. Thomás da Costa Programação Estruturada II
Exemplo 7
#include <iostream>
using namespace std;
int main()
{
int *ptr;
int x;
ptr = &x;
*ptr = 999;
cout << &x << endl;
cout << ptr << endl;
cout << *ptr << endl;
}
xptr
0x23fe440x23fe48
0x23fe48 0x23fe440x23fe44 999
144. Ponteiros
Operação com ponteiros:
Em ponteiros, possuímos operações de incremento e decremento, tanto para
valores como para o endereço do ponteiro.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Operador Descrição
++ Incrementa um valor ou o endereço do ponteiro
-- Decrementa um valor ou o endereço do ponteiro
Quando o valor de um endereço de ponteiro é incrementado ou decrementado, a
operação sempre irá acontecer utilizando o tamanho do tipo da variável. Por
exemplo: se uma variável for do tipo inteiro, o ponteiro será incrementado e
decrementado de 4 em 4.
145. Ponteiros
Como incrementar e decrementar um ponteiro:
No exemplo abaixo, a posição de memória será incrementada e decrementada em
4 posições de acordo com o tamanho da variável inteira.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
int *ptr;
ptr++;
ptr--;
Incremento de ponteiro
Decremento de ponteiro
Somente o endereço do ponteiro
atribuído na variável será
incrementado ou decrementado
146. Ponteiros
Como incrementar e decrementar o valor de um ponteiro:
No exemplo abaixo, o valor de um ponteiro é incrementado e decrementado.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
int *ptr;
(*ptr)++;
(*ptr)--;
Incremento do valor do
ponteiro
Decremento do valor do
ponteiro
O valor atribuído na posição de
memória do ponteiro, será
incrementado ou decrementado
147. Prof. Thomás da Costa Programação Estruturada II
Exemplo 8
#include <iostream>
using namespace std;
int main()
{
int *ptr;
int x;
ptr = &x;
*ptr = 999;
cout << "Valor Original:" << ptr << endl;
ptr++;
cout << "Incremento:" << ptr << endl;
ptr--;
cout << "Decremento:" << ptr << endl;
(*ptr)++;
cout << "Inc. valor:" << *ptr << endl;
(*ptr)--;
cout << "Dec. valor:" << *ptr << endl;
}
Este programa efetua operações com ponteiros. Vamos
analisar com mais detalhes. Para isso iremos ocultar as
linhas de cout, pois não afetam o nosso código
148. Prof. Thomás da Costa Programação Estruturada II
Exemplo 8
#include <iostream>
using namespace std;
int main()
{
int *ptr;
int x;
ptr = &x;
*ptr = 999;
ptr++;
ptr--;
(*ptr)++;
(*ptr)--;
}
ptr
0x23fe38
x
0x23fe34
0x23fe380x23fe34 0x23fe34999
0x23fe380x23fe38 0x23fe34999
0x23fe380x23fe34 0x23fe34999
0x23fe380x23fe34 0x23fe341000
0x23fe380x23fe34 0x23fe34999
149. Prof. Thomás da Costa Programação Estruturada II
Exemplo 9
#include <iostream>
using namespace std;
int main()
{
double *ptr;
double x;
ptr = &x;
*ptr = 999.98;
cout << "Valor Original:" << ptr << endl;
ptr++;
cout << "Incremento:" << ptr << endl;
ptr--;
cout << "Decremento:" << ptr << endl;
(*ptr)++;
cout << "Inc. valor:" << *ptr << endl;
(*ptr)--;
cout << "Dec. valor:" << *ptr << endl;
}
Mesmo processo do programa anterior utilizando outro
tipo de variável.
150. Ponteiros
Comparação de Ponteiros:
Na comparação de ponteiros, utilizamos os operadores maior, menor e igual. O
resultado da comparação, indica se o endereço de ponteiro é igual, se está mais ou
menos avançado que o endereço que está sendo comparado.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
151. Prof. Thomás da Costa Programação Estruturada II
Exemplo 10
#include <iostream>
using namespace std;
int main()
{
int *ptr_1;
int *ptr_2;
int x, y;
ptr_1 = &x;
ptr_2 = &y;
cout << ptr_1 << endl;
cout << ptr_2 << endl;
cout << (ptr_1 > ptr_2) << endl;
cout << (ptr_1 < ptr_2) << endl;
ptr_1 = &x;
ptr_2 = &x;
cout << (ptr_1 == ptr_2) << endl;
}
Ponteiros são iguais
Comparação de ponteiros
152. Ponteiros
Vetores:
Normalmente um vetor, pode ser representado diretamente por um ponteiro. No
caso de um vetor de char, podemos efetuar atribuições diretamente, sem precisar
representá-los por posições de memórias. Isto é uma característica da linguagem e
do compilador.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
153. Prof. Thomás da Costa Programação Estruturada II
Exemplo 11
#include <iostream>
#include <strings.h>
using namespace std;
int main()
{
char valores[100];
char *ptr;
strcpy(valores, "Isto é um teste");
ptr = valores;
cout << valores << endl;
cout << ptr << endl;
ptr = (char *)"Isto é um outro teste";
cout << ptr << endl;
cout << valores[3] << endl;
cout << *(ptr+3) << endl;
}
Exibindo valor na posição
do vetor
154. Ponteiros
Operadores bit-a-bit:
São operações que efetuamos diretamente com os bits de um tipo de dados. Para
isso, cada operador possui uma tabela verdade.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Operador Descrição
& AND
| OR
^ OR Exclusivo (XOR)
~ Negação
>> Deslocamento de bit a direita
<< Deslocamento de bit a esquerda
155. Ponteiros
Tabela verdade dos operadores bit-a-bit:
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
p q p & q
0 0 0
0 1 0
1 0 0
1 1 1
Operador AND (&):
p q p | q
0 0 0
0 1 1
1 0 1
1 1 1
Operador OR(|):
p q p & q
0 0 0
0 1 1
1 0 1
1 1 0
Operador XOR(^):
O operador ~ (NOT), inverte o resultado, se for 0 se torna 1 e vice-versa. Os
operadores >> e <<, deslocam bit a esquerda e a direita.
157. Ponteiros
Resumo:
- Um ponteiro armazena uma posição de memória
- Esta posição de memória é referente a um valor
- Atribuição de ponteiros deve acontecer se for do mesmo tipo
- Podemos efetuar operação de incremento e decremento em ponteiros
- Os operadores bit-a-bit são divididos em AND, OR, XOR, NOT
- Os operadores << e >> representam deslocamento de bit a esquerda e a direita
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
158. Ponteiros
Lista Ligada Simples:
É uma lista de elementos ligados em sequência. Normalmente utilizamos
estruturas para representar lista ligadas.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
159. Ponteiros
Mais detalhes:
- São representados por estruturas
- São estruturas dentro de estruturas encadeadas
- A estrutura interna sempre é um ponteiro para outra estrutura
- Sendo um ponteiro, indica o endereço da próxima estrutura
- Vamos trabalhar com inserção no fim da lista encadeada
- Utilizadas para armazenar valores na memória de fácil acesso
Lista Ligada Simples
Prof. Thomás da Costa Programação Estruturada II
160. Ponteiros
Como funciona:
Um elemento de uma lista, possui o endereço do próximo. O último elemento da
lista tem o valor NULL
Lista Ligada Simples
Prof. Thomás da Costa Programação Estruturada II
1 2 3
Elementos da lista ligada simples
Endereço de memória para o próximo elemento
161. Ponteiros
Lista Ligada Simples
Prof. Thomás da Costa Programação Estruturada II
Exemplo:
Próximo elemento da listastruct alunos
{
char nome[100];
int idade;
alunos *proximo;
} *lista_alunos;
162. Ponteiros
Lista Ligada Simples
Prof. Thomás da Costa Programação Estruturada II
Alocando memória:
Para o nosso exemplo vamos efetuar alocação dinâmica de memória utilizando a
palavra reservada new.
Efetuando alocação de memória
alunos *novo_aluno = new alunos;
163. Prof. Thomás da Costa Programação Estruturada II
Exemplo 13
Adicionando no final da lista
...
alunos *novo_aluno = new alunos;
cout << "Digite o nome do aluno:" << endl;
gets(novo_aluno->nome);
cout << "Digite a idade do aluno:" << endl;
cin >> novo_aluno->idade;
novo_aluno->proximo = NULL;
if (lista_alunos == NULL)
lista_alunos = novo_aluno;
else
{
alunos *p;
p = lista_alunos;
while (p->proximo != NULL)
p = p->proximo;
p->proximo = novo_aluno;
}
...
164. ...
alunos *p;
p = lista_alunos;
if (p->proximo == NULL)
{
cout << "------------------------------------" << endl;
cout << "Nome do Aluno:" << p->nome << endl;
cout << "Idade do Aluno:" << p->idade << endl;
cout << "------------------------------------" << endl;
}
else
{
while (p != NULL)
{
cout << "------------------------------------" << endl;
cout << "Nome do Aluno:" << p->nome << endl;
cout << "Idade do Aluno:" << p->idade << endl;
cout << "------------------------------------" << endl;
p = p->proximo;
}
}
...
Prof. Thomás da Costa Programação Estruturada II
Exemplo 13
Percorrendo a lista ligada
165. Ponteiros
Resumo:
Lembrando os itens do começo desse tópico:
- São representados por estruturas
- São estruturas dentro de estruturas encadeadas
- A estrutura interna sempre é um ponteiro para outra estrutura
- Sendo um ponteiro, indica o endereço da próxima estrutura
- Utilizadas para armazenar valores na memória de fácil acesso
Lista Ligada Simples
Prof. Thomás da Costa Programação Estruturada II
167. Recursividade
O que é:
É quando uma função, invoca a si mesma para resolver um problema em uma
instância menor.
Recursividade
Prof. Thomás da Costa Programação Estruturada II
168. Recursividade
Mais detalhes:
- É quando uma função invoca a si mesmo
- As chamadas devem possuir um fim
- O programa pode ficar em um loop infinito
- Dependendo da sua forma de utilização, pode ser lento
- Existe uma pilha de execução
- Simplifica algumas lógicas de programação
- Programas recursivos são complexos
- Possuem grande semelhança com instruções de laços
- Muito cuidado: existe um limite para uma função chamar a si próprio
- Esse limite é definido por cada compilador e linguagem
Recursividade
Prof. Thomás da Costa Programação Estruturada II
Vamos ver um exemplo !!!
169. Recursividade
Exemplo de Fatorial:
No nosso exemplo vamos utilizar fatorial !!!
O que é fatorial?
É o produto de todos os seus antecessores, incluindo si próprio e excluindo o zero
Exemplo: 6! = 6 * 5 * 4 * 3 * 2 * 1 = 720
FATORIAL DE 6 É 720 !!!
Recursividade
Prof. Thomás da Costa Programação Estruturada II
170. Prof. Thomás da Costa Programação Estruturada II
Exemplo 1
#include <iostream>
using namespace std;
int calcular_fatorial(int valor);
int main()
{
cout << "Valor do fatorial:" << calcular_fatorial(6);
}
int calcular_fatorial(int valor)
{
if (valor == 0)
return 1;
else
{
valor = (valor * calcular_fatorial(valor - 1));
cout << valor << endl;
return valor;
}
}
Chamada recursiva
Vamos ver o programa
passo-a-passo, analisando a
pilha de execução
171. Prof. Thomás da Costa Programação Estruturada II
Exemplo 1
...
int calcular_fatorial(int valor)
{
if (valor == 0)
return 1;
else
{
valor = (valor * calcular_fatorial(valor - 1));
cout << valor << endl;
return valor;
}
}
calcular_fatorial(6) -> valor = (6 * calcular_fatorial(5));
calcular_fatorial(5) -> valor = (5 * calcular_fatorial(4));
calcular_fatorial(4) -> valor = (4 * calcular_fatorial(3));
calcular_fatorial(3) -> valor = (3 * calcular_fatorial(2));
calcular_fatorial(2) -> valor = (2 * calcular_fatorial(1));
calcular_fatorial(1) -> valor = (1 * calcular_fatorial(0));
calcular_fatorial(0) -> return 1;
Pilha de execução
Fim da recursividade
172. Prof. Thomás da Costa Programação Estruturada II
Exemplo 1
...
int calcular_fatorial(int valor)
{
if (valor == 0)
return 1;
else
{
valor = (valor * calcular_fatorial(valor - 1));
cout << valor << endl;
return valor;
}
}
calcular_fatorial(6) -> valor = (6 * 5 * 4 * 3 * 2 * 1 * 1);
calcular_fatorial(5) -> valor = (5 * 4 * 3 * 2 * 1 * 1);
calcular_fatorial(4) -> valor = (4 * 3 * 2 * 1 * 1);
calcular_fatorial(3) -> valor = (3 * 2 * 1 * 1);
calcular_fatorial(2) -> valor = (2 * 1 * 1);
calcular_fatorial(1) -> valor = (1 * 1);
calcular_fatorial(0) -> return 1;
173. Recursividade
Exemplo de Potenciação:
No próximo exemplo, vamos ver como criar um programa de potenciação.
O que é potenciação?
É o produto de um número por ele mesmo, em uma quantidade de vezes definida.
Exemplo: 5³ = 5 * 5 * 5 = 125
POTÊNCIA DE 5 É 125 !!!
Recursividade
Prof. Thomás da Costa Programação Estruturada II
174. #include <iostream>
using namespace std;
int potencia(int base, int expoente);
int main()
{
int base = 5;
int expoente = 3;
cout << "Potencia:" << potencia(base, expoente);
}
int potencia(int base, int expoente)
{
if (expoente == 0)
return 1;
else
{
int valor = base * potencia(base, expoente - 1);
cout << valor << endl;
return valor;
}
}
Prof. Thomás da Costa Programação Estruturada II
Exemplo 2
Chamada recursiva
175. Recursividade
Resumo:
Vamos relembrar os itens do começo da aula:
- É quando uma função invoca a si mesmo
- As chamadas devem possuir um fim
- O programa pode ficar em um loop infinito
- Dependendo da sua forma de utilização, pode ser lento
- Existe uma pilha de execução
- Simplifica algumas lógicas de programação
- Programas recursivos são complexos
- Possuem grande semelhança com instruções de laços
- Muito cuidado: existe um limite para uma função chamar a si próprio
Recursividade
Prof. Thomás da Costa Programação Estruturada II
176. Recursividade
Prof. Thomás da Costa Programação Estruturada II
Semestre concluído !!! Parabéns a todos !!!
THANKS FOR STUDYING
179. Melhores Práticas
O que é:
É uma forma de deixar mais legível o código-fonte de um programa, usando
tabulações e espaços entre desvios condicionais, laços, variáveis e outros
comandos.
Indentação do Código-Fonte
Prof. Thomás da Costa Programação Estruturada II
Vamos ver um exemplo !!!
180. Melhores Práticas
Indentação do Código-Fonte
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
using namespace std;
int main()
{
int idade;
cout << "Digite sua idade:";
cin >> idade;
if (idade >= 21)
{
cout << "Maior de idade";
}
else
{
cout << "Menor de idade";
}
}
Código bem tabulado e com
espaçamentos, é possível saber
aonde começa e termina o desvio
condicional
181. Melhores Práticas
Indentação do Código-Fonte
Prof. Thomás da Costa Programação Estruturada II
#include <iostream>
using namespace std;
int main()
{
int idade;
cout << "Digite sua idade:";
cin >> idade;
if(idade >= 21)
{cout << "Maior de idade";
}
else
{
cout << "Menor de idade";
}
}
Código RUIM !!! Mal tabulado e sem
espaçamentos. Difícil de entender
aonde começa e termina cada
instrução
182. Melhores Práticas
Não se esqueçam:
Fazer a indentação dos códigos-fontes nas aulas de lab, nos exercícios, trabalhos e
avaliações
Indentação do Código-Fonte
Prof. Thomás da Costa Programação Estruturada II
184. Dicas e Truques
Atenção:
- Preste bastante atenção ao digitar um código fonte. Qualquer erro significa que o
programa pode não compilar ou uma funcionalidade pode parar de executar
- Cuidado ao digitar nomes de funções: uma letra errada ao chamar uma função significa
erro de compilação
- Todos os comandos aprendidos em C++ são em letras minúsculas. Comandos digitado
em letra maiúscula, significa erro de compilação
- Atribuir corretamente os tipos de variáveis para não acontecer erros de conversão. Por
exemplo: inteiro recebe um inteiro, um ponto flutuante recebe um valor numérico
separado por ponto(.)
- As aberturas de chaves definem um escopo. Uma abertura de chave errada, pode gerar
um resultado inesperado ou um erro de compilação
- Instruções terminam com ponto e vírgula. Colocando este operador, significa que a
instrução deve ser concluída. Cuidado ao colocar em if, for e while, para evitar
instruções sem conteúdo
Recomendações
Prof. Thomás da Costa Programação Estruturada II
185. Dicas e Truques
Não se esqueçam:
Sigam as dicas, para desenvolver programas com o menor número de problemas e
erros de compilação.
Dicas e Truques
Prof. Thomás da Costa Programação Estruturada II
187. Ferramentas e Sites
Vamos lá:
Iremos conhecer novas ferramentas para o desenvolvimento em C/C++ e alguns
sites para aprimorar o conhecimento em programação de softwares.
Ferramentas e Sites
Prof. Thomás da Costa Programação Estruturada II
Vamos conhecer as ferramentas e
sites !!!
188. Ferramentas e Sites
CodeLite IDE
http://codelite.org/
Ferramentas
Prof. Thomás da Costa Programação Estruturada II
Code::Blocks
http://www.codeblocks.org/
Visual Studio Community 2013
https://www.visualstudio.com/en-us/products/visual-
studio-community-vs.aspx
Eclipse CDT
https://eclipse.org/cdt/
189. Ferramentas e Sites
Sites
Prof. Thomás da Costa Programação Estruturada II
Microsoft Virtual Academy
http://www.microsoftvirtualacademy.com/
Codecademy
http://www.codecademy.com/pt
Veduca
http://www3.veduca.com.br/
Coursera
https://pt.coursera.org/
Udemy
https://www.udemy.com/
190. Ferramentas e Sites
Importante:
Programação envolve muito treino, prática, estudo, pesquisa e curiosidade. Este
material complementar pode ajudá-los em todos os itens mencionados.
Ferramentas e Sites
Prof. Thomás da Costa Programação Estruturada II