Programação Estruturada II - Revisão Completa

Programação Estruturada II
Curso Completo
Prof. Thomás da Costa
thomasdacosta@gmail.com
Anhanguera – 2015.1

Apresentação
- 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

Revisão
REVISÃO

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

Revisão
Variáveis:
Revisão
#include <iostream>
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

Revisão
Operadores:
Revisão
#include <iostream>
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>
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
}

Revisão
Desvios Condicionais:
Revisão
#include <iostream>
int main()
{
int idade;
cout << "Digite sua idade:";
cin >> idade;
if (idade >= 21)
{
cout << "Maior de idade";
}
else
{
cout << "Menor de idade";
}
}
#include <iostream>
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:
break;
case 3:
break;
default:
cout << "Nenhuma Opção Selecionada";
break;
}
}
Condição
Condições

Revisão
Laço (Loops):
Revisão
#include <iostream>
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

Revisão
Vetores:
Revisão
#include <iostream>
#include <string.h>
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

Depuração e Documentação
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

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
BUGS = DEFEITOS = ERROS

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

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>
int main()
{
int value[10];
int i = 0;
for (;i<=10;i++)
{
value[i] = i;
cout << i;
}
}

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 !!!

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

“Debugando”:
Executando linha por linha

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

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

Bloco de comentário
Comentário em linha
#include <iostream>
/**
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";
}
}

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

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>
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";
}
}

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>
int main()
{
int fat=6;
int fatorial = 1;
while (fat >= 1)
{
fatorial *= fat;
}
cout << fatorial << "n";
}

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>
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";
}
}
}

Modularização e Funções
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.

Veja o exemplo abaixo:
Um carro é composto por vários componentes (portas, rodas, motor e etc). Esses
componentes tornam o carro modular.
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.

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 em C/C++:
Em C++ a modularização é feita a partir de blocos de funcionalidades, denominado
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

CALCULADORA
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.

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

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;
}

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

Funções
Como Utilizar em C++:
As quatro funções da calculadora
Protótipo das funções
#include <iostream>
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
{
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;
}

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>
int main()
{
double valor;
valor = somar(10,15);
}
...

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

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>
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;
}

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>
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;
}

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>
void dividir(int x, int y);
int main()
{
int x, y;
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

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

Exemplo – Imprime na tela:
Funções
#include <iostream>
void imprimir();
int main()
{
imprimir();
}
void imprimir()
{
char valor[10];
cout << "Digite algo:n";
gets(valor);
cout << valor;
}

Exemplo – Quadrado:
Funções
#include <iostream>
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;
}

Exemplo – Conversor de Moedas:
Funções
#include <iostream>
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;
}

Exemplo – Calculadora:
Funções
#include <iostream>
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);
cin >> x >> y;
cout << dividir(x, y);
}
{
return resultado;
}
{
double resultado = x - y;
return resultado;
}
{
double resultado = x * y;
return resultado;
}
{
double resultado = x / y;
return resultado;
}

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

Exemplo:
Escopo de Variáveis
#include <iostream>
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

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

#include <iostream>
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;
}
Exemplo:
Parâmetros Por Valor
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

Parâmetros Por Referência
O que é:
É quando uma variável é passada como parâmetro de uma função, e seu valor
original pode ser alterado.

#include <iostream>
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;
}
Exemplo:
Parâmetros Por Referência
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

Exemplo:
Parâmetros do Tipo String
#include <iostream>
#include <string.h>
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 ( * )

Exemplo:
Parâmetros do Tipo Vetor
#include <iostream>
#include <string.h>
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

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
Para acontecer a sobrecarga:
- Tipos de parâmetros diferentes
- Quantidades de parâmetros

Exemplo:
#include <iostream>
#include <string.h>
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

Exemplo - Continuação:
void imprime_vetor(char *valores)
{
cout << "void imprime_vetor(char *valores)" << endl;
{
}
}
void imprime_vetor(int *valores)
{
cout << "void imprime_vetor(int *valores)" << endl;
{
}
}
void imprime_vetor(int *valores, int tamanho)
{
cout << "void imprime_vetor(int *valores, int tamanho)" << endl;
for (int i=0;i<tamanho;i++)
{
}
}

Exemplo:
Valores Default
#include <iostream>
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

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

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

Vamos criar uma biblioteca matemática:
- Criar arquivo .h
- Criar arquivo .cpp
Bibliotecas
Arquivos da biblioteca .h e .cpp

namespace matematica
{
}
Arquivo .h:
Bibliotecas
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

#include <iostream>
#include "matematica.h"
namespace matematica
{
{
return x + y;
}
{
return x - y;
}
{
return x * y;
}
{
return x / y;
}
}
Arquivo .cpp:
Bibliotecas
Implementações das funções

#include <iostream>
#include "matematica.h"
using namespace matematica;
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;
}
Usando a biblioteca:
Bibliotecas
Chamando as funções
Incluindo a biblioteca no programa

Estruturas, Uniões e Enumeração
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

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

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
Vamos ver como fazer uma estrutura em
C/C++ !!!

Estruturas em C/C++:
Estruturas
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

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
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

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
#include <iostream>
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;
}

Estruturas
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:

Acessando membros de uma estrutura:
Para acessar um membro de uma estrutura utilizamos o operador ponto (.)
Estruturas
...
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

Atribuindo valores para membros de uma função:
Estruturas
#include <iostream>
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;
}
Atribuição de valores

Estruturas
#include <iostream>
#include <string.h>
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

Estruturas
#include <iostream>
#include <string.h>
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

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

Passando membros de uma estrutura como parâmetro:
Estruturas em Funções
#include <iostream>
#include <string.h>
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

Parâmetros por referência:
...
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

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
...
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

Estrutura como parâmetro (Por referência):
#include <iostream>
#include <string.h>
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.

Vetores de Estruturas:
Estruturas
#include <iostream>
#include <string.h>
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

Estruturas dentro de estruturas:
Estruturas
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

Exemplo (Média):
Estruturas
#include <iostream>
#include <string.h>
struct aluno
{
char nome[100];
double nota_b1;
double nota_b2;
};
double media(double nota_b1, double
nota_b2);
int main()
{
struct aluno alu;
cout << "Nota B1:" << endl;
cin >> alu.nota_b1;
cout << "Nota B2:" << endl;
cin >> alu.nota_b2;
cout << "Media:" <<
media(alu.nota_b1, alu.nota_b2);
}
double media(double nota_b1, double nota_b2)
{
return (nota_b1 + nota_b2) / 2;
}

Exemplo (Aumentar Salário):
Estruturas
#include <iostream>
#include <string.h>
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 !!!

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

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
Vamos ver como fazer uma união
em C/C++ !!!

Uniões em C/C++:
Uniões
Nome da união
Palavra reservada
que identifica uma
união Membros da união
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;
};

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
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

Exemplo:
Uniões
#include <iostream>
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();
imprimir();
imprimir();
imprimir();
}
void imprimir()
{
cout << "Valores:" << endl;
cout << valor.valor_1 << endl;
}

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

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

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
Vamos ver como fazer uma enumeração em C/C++ !!!

Enumerações em C/C++:
Enumeração
Nome do enum
Palavra reservada
que identifica um
enum
Valores inteiros de um enum
e o fim do enum
Termina com ponto e
vírgula
enum despesas
{
ALUGUEL,
FACULDADE,
CELULAR,
INTERNET,
CONTA_AGUA,
CONTA_LUZ
};

Exemplo:
Enumeração
#include <iostream>
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

Exemplo:
Vamos modificar o programa feito no laboratório para utilizar enumeração.
(Exercício 4 do nível básico).
Enumeração
...
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

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
#include <iostream>
#include <strings.h>
typedef char valores[100];
int main()
{
valores val;
strcpy(val, "Programação Estruturada II");
cout << "Tipo do usuário:" << val;
}

Arquivos
ARQUIVOS

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

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

Arquivos
Criando arquivos textos em C++:
Arquivos
#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

#include <iostream>
#include <fstream>
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

Arquivos
Lendo arquivos textos em C++:
Arquivos
#include <fstream>
...
ifstream ifs;
ifs.open("ola_mundo.txt", ios::in);
Nome do arquivo

#include <iostream>
#include <fstream>
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

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
Utilizar o comando close() dos objetos
ofstream e ifstream !!!

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

#include <iostream>
#include <fstream>
int main()
{
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.close();
}
Exemplo 3
Lendo valores a partir do teclado
Gravando os valores sequencialmente

#include <iostream>
#include <fstream>
void ler_arquivo();
int main()
{
ler_arquivo();
}
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())
{
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

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
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

#include <iostream>
#include <fstream>
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

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
O comando getline busca sempre o
fim de linha

#include <iostream>
#include <fstream>
int main()
{
gravar_arquivo();
}
{
string valor;
ofstream ofs;
ofs.open("arquivo_linhas.txt", ios::out);
valor = "O que são funções:";
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.";
valor = "As funções são reutilizáveis dentro de um programa.";
ofs.close();
}
Exemplo 6
Criando um arquivo com várias
linhas. No nosso caso, 3 linhas.

#include <iostream>
#include <fstream>
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())
{
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

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
Vamos ver a nova forma de gravação em arquivos !!!

#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
Nome do arquivo

fst.write((char *)&alu, sizeof(alu));
Arquivos
Gravando uma estrutura em um arquivo:
Arquivos
Comando para gravação
“Cast” da estrutura para char
Tamanho da estrutura que será gravada

Exemplo 8
#include <iostream>
#include <fstream>
#include <limits>
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;
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

fst.read((char *)&alu,sizeof(alu))
Arquivos
Lendo uma estrutura em um arquivo:
Arquivos
Comando para leitura
“Cast” da estrutura para char
Tamanho da estrutura que será lida

Exemplo 9
#include <iostream>
#include <fstream>
#include <limits>
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;
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

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

Ponteiros
PONTEIROS

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

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

Ponteiros
Operadores:
Para operação com ponteiros, utilizamos dois operadores unários:
Ponteiros
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 !!!

Ponteiros
Ponteiros
Declarando uma variável do tipo ponteiro:
int *ptr;
Tipo da variável
Nome da variável
Operador unário

Exemplo 1#include <iostream>
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

Ponteiros
Ponteiros
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;

Exemplo 2
#include <iostream>
int main()
{
int valor;
int *ptr;
valor = 1500;
ptr = &valor;
cout << *ptr << endl;
}
ptrvalor
0x23fe480x23fe44
0x23fe480x23fe44 0x23fe441500

Ponteiros
Ponteiros
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 !!!

Exemplo 3
#include <iostream>
int main()
{
int valor;
int *ptr;
int total;
valor = 1600;
ptr = &valor;
total = *ptr;
cout << total << endl;
}
ptrvalor
0x23fe480x23fe44
total
0x23fe40
0x23fe480x23fe44 0x23fe401600 0x23fe44 1600

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

Exemplo 4
#include <iostream>
int main()
{
// PROGRAMA COM ERRO NAO COMPILA !!!!
int *ptr_inteiro;
double valor;
valor = 345.76;
ptr_inteiro = &valor;
cout << *ptr_inteiro << endl;
}
ERRO !!!

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

Ponteiros
Ponteiros
int *ptr_inteiro;
double valor;
ptr_inteiro = (int *)&valor;
Conversão de valores

Ponteiros
Temos um pequeno problema quando existe a conversão de ponteiros de tipos
diferentes. Vamos ver no próximo exemplo.
Ponteiros

Exemplo 5
#include <iostream>
int main()
{
double valor;
int *ptr_inteiro;
valor = 345.76;
ptr_inteiro = (int *)&valor;
}
ptr_inteirovalor
0x23fe480x23fe40
0x23fe40345.76 0x23fe480x23fe40
Valor exibido:
-171798692
Valor incorreto exibido pelo ponteiro !!!

Exemplo 6
#include <iostream>
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 << valor_2 << endl;
}
São exibidos valores errados
Conversão não funciona completamente

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
*ptr = 999;
Variável do tipo ponteiro
Atribuindo um valor

Exemplo 7
#include <iostream>
int main()
{
int *ptr;
int x;
ptr = &x;
*ptr = 999;
cout << &x << endl;
}
xptr
0x23fe440x23fe48
0x23fe48 0x23fe440x23fe44 999

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
++ 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.

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
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

Ponteiros
Como incrementar e decrementar o valor de um ponteiro:
No exemplo abaixo, o valor de um ponteiro é incrementado e decrementado.
Ponteiros
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

Exemplo 8
#include <iostream>
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

Exemplo 8
#include <iostream>
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

Exemplo 9
#include <iostream>
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.

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

Exemplo 10
#include <iostream>
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

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

Exemplo 11
#include <iostream>
int main()
{
char valores[100];
char *ptr;
strcpy(valores, "Isto é um teste");
ptr = valores;
cout << valores << endl;
ptr = (char *)"Isto é um outro teste";
cout << valores[3] << endl;
cout << *(ptr+3) << endl;
}
Exibindo valor na posição
do vetor

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
& AND
| OR
^ OR Exclusivo (XOR)
~ Negação
>> Deslocamento de bit a direita
<< Deslocamento de bit a esquerda

Ponteiros
Tabela verdade dos operadores bit-a-bit:
Ponteiros
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.

Exemplo 12
#include <iostream>
#include <stdlib.h>
int main()
{
int *ptr_1, *ptr_2;
int valor_1, valor_2;
char valor_convertido[100];
ptr_1 = &valor_1;
ptr_2 = &valor_2;
valor_1 = 316;
valor_2 = 206;
*ptr_1 = *ptr_1 << 2;
cout << *ptr_1 << endl;
*ptr_1 = *ptr_1 >> 2;
cout << *ptr_1 << endl;
itoa(*ptr_1, valor_convertido, 2);
cout << "Valor binário:" << valor_convertido << endl;
itoa(*ptr_2, valor_convertido, 2);
cout << "Valor binário:" << valor_convertido << endl;
itoa(*ptr_2 & *ptr_1, valor_convertido, 2);
cout << "Operador AND:" << valor_convertido << endl;
itoa(*ptr_2 | *ptr_1, valor_convertido, 2);
cout << "Operador OR:" << valor_convertido << endl;
itoa(*ptr_2 ^ *ptr_1, valor_convertido, 2);
cout << "Operador XOR:" << valor_convertido << endl;
itoa(~*ptr_2, valor_convertido, 2);
cout << "Operador NEG:" << valor_convertido << endl;
}
Converte um número para
uma base específica

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

Ponteiros
Lista Ligada Simples:
É uma lista de elementos ligados em sequência. Normalmente utilizamos
estruturas para representar lista ligadas.
Ponteiros

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

Ponteiros
Como funciona:
Um elemento de uma lista, possui o endereço do próximo. O último elemento da
lista tem o valor NULL
1 2 3
Elementos da lista ligada simples
Endereço de memória para o próximo elemento

Ponteiros
Exemplo:
Próximo elemento da listastruct alunos
{
char nome[100];
int idade;
alunos *proximo;
} *lista_alunos;

Ponteiros
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;

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;
}
...

...
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;
}
}
...
Exemplo 13
Percorrendo a lista ligada

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

Recursividade
RECURSIVIDADE

Recursividade
O que é:
É quando uma função, invoca a si mesma para resolver um problema em uma
instância menor.
Recursividade

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
Vamos ver um exemplo !!!

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

Exemplo 1
#include <iostream>
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

Exemplo 1
...
{
if (valor == 0)
return 1;
else
{
return valor;
}
}
calcular_fatorial(6) -> valor = (6 * calcular_fatorial(5));
calcular_fatorial(0) -> return 1;
Pilha de execução
Fim da recursividade

Exemplo 1
...
{
if (valor == 0)
return 1;
else
{
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;

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

#include <iostream>
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);
return valor;
}
}
Exemplo 2
Chamada recursiva

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

Recursividade
Semestre concluído !!! Parabéns a todos !!!
THANKS FOR STUDYING

Programação Estruturada II
Aulas de Laboratório
thomasdacosta@gmail.com
Anhanguera – 2015.1

Melhores Práticas
MELHORES PRÁTICAS

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
Vamos ver um exemplo !!!

Melhores Práticas
#include <iostream>
int main()
{
int idade;
cin >> idade;
if (idade >= 21)
{
cout << "Maior de idade";
}
else
{
}
}
Código bem tabulado e com
espaçamentos, é possível saber
aonde começa e termina o desvio
condicional

Melhores Práticas
#include <iostream>
int main()
{
int idade;
cin >> idade;
if(idade >= 21)
{cout << "Maior de idade";
}
else
{
}
}
Código RUIM !!! Mal tabulado e sem
espaçamentos. Difícil de entender
aonde começa e termina cada
instrução

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

Dicas e Truques
DICAS E TRUQUES

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

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

Ferramentas e Sites
FERRAMENTAS E SITES

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
Vamos conhecer as ferramentas e
sites !!!

Ferramentas e Sites
CodeLite IDE
http://codelite.org/
Ferramentas
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/

Ferramentas e Sites
Sites
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/

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

Obrigado !!!

Programação Estruturada II - Revisão Completa

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a Programação Estruturada II - Revisão Completa

Similar a Programação Estruturada II - Revisão Completa (20)

Más de thomasdacosta

Más de thomasdacosta (20)

Programação Estruturada II - Revisão Completa