Você está na página 1de 114

Anhanguera 2015.1

Anhanguera – 2015.1 Programação Estruturada II Curso Completo
Anhanguera – 2015.1 Programação Estruturada II Curso Completo
Anhanguera – 2015.1 Programação Estruturada II Curso Completo

Programação Estruturada II

Curso Completo

Anhanguera – 2015.1 Programação Estruturada II Curso Completo
Apresentação INSTRUÇÕES: TUTORIA - MONTAR UM DOCUMENTO COM OS SEGUINTES CONCEITOS: Variáveis / Operadores /Desvios

Apresentação

Apresentação INSTRUÇÕES: TUTORIA - MONTAR UM DOCUMENTO COM OS SEGUINTES CONCEITOS: Variáveis / Operadores /Desvios
Apresentação INSTRUÇÕES: TUTORIA - MONTAR UM DOCUMENTO COM OS SEGUINTES CONCEITOS: Variáveis / Operadores /Desvios

INSTRUÇÕES:

TUTORIA

- MONTAR UM DOCUMENTO COM OS SEGUINTES CONCEITOS:

Variáveis / Operadores /Desvios Condicionais /Laço (loops) Vetores /Análise de erros /Breakpoints /Watch /Depuração (Debug) / Arquivos / Ponteiros / Recursividade

Somente conceitos Referencial Teórico (Quem disse?)

ENTREGAR NO DIA DA PROVA

Revisão REVISÃO Programação Estruturada II

Revisão

Revisão REVISÃO Programação Estruturada II
Revisão REVISÃO Programação Estruturada II
Revisão REVISÃO Programação Estruturada II

REVISÃO

Revisão Revisão Estrutura de um programa C++: #include <iostream> Bibliotecas de funções using namespace

Revisão

Revisão Revisão Estrutura de um programa C++: #include <iostream> Bibliotecas de funções using namespace
Revisão Revisão Estrutura de um programa C++: #include <iostream> Bibliotecas de funções using namespace

Revisão Estrutura de um programa C++:

Revisão Revisão Estrutura de um programa C++: #include <iostream> Bibliotecas de funções using namespace

#include <iostream>

Bibliotecas de funções

using namespace std;

Bibliotecas de funções using namespace std; Identificador da função int main() { Função principal

Identificador da função

int main()

{

namespace std; Identificador da função int main() { Função principal do programa cout << "Olá

Função principal do programa

cout << "Olá Mundo !!!";

}

Revisão Variáveis: #include <iostream> using namespace std; Revisão Tipo da variável int main() { const

Revisão

Revisão Variáveis: #include <iostream> using namespace std; Revisão Tipo da variável int main() { const
Revisão Variáveis: #include <iostream> using namespace std; Revisão Tipo da variável int main() { const

Variáveis:

#include <iostream>

using namespace std;

Revisão

Tipo da variável int main() { const float numero_pi = 3.14; char genero = 'M';
Tipo da variável
int main()
{
const float numero_pi = 3.14;
char genero = 'M';
int idade = 31;
Nome da variável
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;
double nota1, nota2;
cout << "Digite as notas:" << endl;
cin
>> nota1 >> nota2;

cout << "Notas: " << nota1 << "-" << nota2;

}

Ler uma variável a partir

do teclado

Revisão Operadores: #include <iostream> using namespace std; int main () { Revisão int x =

Revisão

Revisão Operadores: #include <iostream> using namespace std; int main () { Revisão int x = 10
Revisão Operadores: #include <iostream> using namespace std; int main () { Revisão int x = 10

Operadores:

#include <iostream>

using namespace std;

int main()

{

Revisão

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

}

c *= 1; // atribuição multiplicação d /= 1; // atribuição divisão e %= 1; //
Revisão Revisão Desvios Condicionais: #include <iostream> #include <iostream> using namespace std;

Revisão

Revisão Revisão Desvios Condicionais: #include <iostream> #include <iostream> using namespace std;
Revisão Revisão Desvios Condicionais: #include <iostream> #include <iostream> using namespace std;

Revisão

Desvios Condicionais:

#include <iostream>

#include <iostream>

using namespace std;

using namespace std;

int main() int main() Condição { { int idade; cout << "Digite sua idade:"; cin
int main()
int main()
Condição
{
{
int idade;
cout << "Digite sua idade:";
cin >> idade;
if (idade >= 21)
switch (opcao)
{
{
cout << "Maior de idade";
case 1:
}
else
{
cout << "Menor de idade";
}
}
Condições

int opcao; cout << "Informe uma opção (1,2,3):"; cin >> opcao;

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;

}

}

3 Selecionada" ; break ; default : cout << "Nenhuma Opção Selecionada" ; break ; }
Revisão Revisão Laço (Loops): #include <iostream> Condição inicial, final do loop e contador using namespace

Revisão

Revisão Revisão Laço (Loops): #include <iostream> Condição inicial, final do loop e contador using namespace
Revisão Revisão Laço (Loops): #include <iostream> Condição inicial, final do loop e contador using namespace

Revisão

Laço (Loops):

#include <iostream>

Condição inicial, final do loop e contador

using namespace std; int main() { for (int i=0;i<=10;i++) { cout << i << "\n";
using namespace std;
int main()
{
for
(int i=0;i<=10;i++)
{
cout << i << "\n";
}
int j = 0;

while (j <=10)

{

"\n"; } int j = 0; while (j <=10) { Condição do loop. Pode não entrar

Condição do loop. Pode não entrar na rotina

cout << j << "\n"; j++;

Condição do loop, passa pelo menos uma vez na rotina

} { } }
}
{
}
}

int k = 0; do

cout << k << "\n"; k++;

while (k <= 10);

uma vez na rotina } { } } int k = 0; do cout << k
Revisão Revisão Vetores: Criando um vetor com 10 posições #include <iostream> #include <string.h>

Revisão

Revisão Revisão Vetores: Criando um vetor com 10 posições #include <iostream> #include <string.h>
Revisão Revisão Vetores: Criando um vetor com 10 posições #include <iostream> #include <string.h>

Revisão

Vetores:

Criando um vetor com 10 posições #include <iostream> #include <string.h> using namespace std; int
Criando um vetor com 10 posições
#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;
Inicializando um vetor
(int i=9;i>=0;i--) { k[i] = i; Inicializando um vetor } cout << k[i] << "\n" ;
}
}

cout << k[i] << "\n";

Atribuindo um

valor na posição

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

char usuario[100];

gets(usuario);// lê a string do teclado

usuario[100]; gets (usuario); // lê a string do teclado cout << "Usuário: " << usuario;

cout << "Usuário: " << usuario;

Ler um vetor de char pelo teclado

// lê a string do teclado cout << "Usuário: " << usuario; Ler um vetor de
Depuração e Documentação DEPURAÇÃO E DOCUMENTAÇÃO

Depuração e Documentação

Depuração e Documentação DEPURAÇÃO E DOCUMENTAÇÃO
Depuração e Documentação DEPURAÇÃO E DOCUMENTAÇÃO
Depuração e Documentação DEPURAÇÃO E DOCUMENTAÇÃO

DEPURAÇÃO E DOCUMENTAÇÃO

Depuração e Documentação DEPURAÇÃO E DOCUMENTAÇÃO
Depuração e Documentação Depuração ou Debug O que é: É uma técnica para executar uma

Depuração e Documentação

Depuração e Documentação Depuração ou Debug O que é: É uma técnica para executar uma aplicação
Depuração e Documentação Depuração ou Debug O que é: É uma técnica para executar uma aplicação

Depuração ou Debug

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.

a passo, identificando possíveis erros (bug) ou para o entendimento de uma funcionalidade do programa pelo
a passo, identificando possíveis erros (bug) ou para o entendimento de uma funcionalidade do programa pelo
Depuração e Documentação Depuração ou Debug Mais um pouco: - Executa o programa linha a

Depuração e Documentação

Depuração e Documentação Depuração ou Debug Mais um pouco: - Executa o programa linha a linha
Depuração e Documentação Depuração ou Debug Mais um pouco: - Executa o programa linha a linha

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

das variáveis em tempo de execução - Breakpoints - Analise das funções do código fonte BUGS

BUGS = DEFEITOS = ERROS

das variáveis em tempo de execução - Breakpoints - Analise das funções do código fonte BUGS
Depuração e Documentação Depuração ou Debug Como fazer análise de um erro: Tendo a premissa

Depuração e Documentação

Depuração e Documentação Depuração ou Debug Como fazer análise de um erro: Tendo a premissa que
Depuração e Documentação Depuração ou Debug Como fazer análise de um erro: Tendo a premissa que

Depuração ou Debug Como fazer análise de um erro:

Tendo a premissa que conhecemos o programa a ser depurado, podemos seguir os

seguintes passos:

- 1º Passo:

depurado, podemos seguir os seguintes passos: - 1º Passo: Verificar o problema reportado (normalmente por um

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

o problema, efetuar a leitura do código e ver possíveis erros de codificação ou utilizar uma
Depuração e Documentação Depuração ou Debug Análise de Código: No caso do código abaixo, conseguimos

Depuração e Documentação

Depuração e Documentação Depuração ou Debug Análise de Código: No caso do código abaixo, conseguimos identificar
Depuração e Documentação Depuração ou Debug Análise de Código: No caso do código abaixo, conseguimos identificar

Depuração ou Debug

Análise de Código:

No caso do código abaixo, conseguimos identificar um possível problema em nosso

programa ?

#include <iostream>

Sim temos !!!

using namespace std;

Nosso vetor de inteiros, possui 10 posições e

para percorrer um vetor é sempre a posição 1.

int main() { int value[10]; int i = 0; for (;i<=10;i++) { value[i] = i;
int main()
{
int value[10];
int i = 0;
for (;i<=10;i++)
{
value[i] = i;
cout << i;
}
}

Então o i <= 10 deveria ser i <= 9

int i = 0; for (;i<=10;i++) { value[i] = i; cout << i; } } Então
Depuração e Documentação Depuração ou Debug Debug no DevC++: Muitas vezes efetuamos a análise do

Depuração e Documentação

Depuração e Documentação Depuração ou Debug Debug no DevC++: Muitas vezes efetuamos a análise do código,
Depuração e Documentação Depuração ou Debug Debug no DevC++: Muitas vezes efetuamos a análise do código,

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.

isso as ferramentas modernas, possuem funcionalidades que permitem rodar o programa linha a linha. Caçando os

Caçando os BUGS !!!

isso as ferramentas modernas, possuem funcionalidades que permitem rodar o programa linha a linha. Caçando os
Depuração e Documentação Depuração ou Debug Breakpoints: São marcações efetuadas na ferramenta, que tem como

Depuração e Documentação

Depuração e Documentação Depuração ou Debug Breakpoints: São marcações efetuadas na ferramenta, que tem como
Depuração e Documentação Depuração ou Debug Breakpoints: São marcações efetuadas na ferramenta, que tem como

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
Marcação do breakpoint
continue para a próxima instrução. Na imagem abaixo, o programa interrompe na linha 12. Marcação do
Depuração e Documentação Depuração ou Debug “ Debugando ” : Executando linha por linha

Depuração e Documentação

Depuração e Documentação Depuração ou Debug “ Debugando ” : Executando linha por linha
Depuração e Documentação Depuração ou Debug “ Debugando ” : Executando linha por linha

Depuração ou Debug

Debugando:

Executando linha por linha
Executando linha por linha
Depuração e Documentação Depuração ou Debug “ Debugando ” : Executando linha por linha

Depuração e DocumentaçãoDepuração ou Debug Watch: No processo de depuração conseguimos visualizar os valores das variáveis em

Depuração e Documentação Depuração ou Debug Watch: No processo de depuração conseguimos visualizar os valores das
Depuração e Documentação Depuração ou Debug Watch: No processo de depuração conseguimos visualizar os valores das

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

podemos ver as variáveis do programa sendo preenchidas Valores das variáveis em tempo de execução Botão

Valores das variáveis em tempo de execução

Botão Add Watch

podemos ver as variáveis do programa sendo preenchidas Valores das variáveis em tempo de execução Botão
Depuração e Documentação

Depuração e Documentação

Depuração e Documentação
Depuração e Documentação
Depuração e Documentação
Depuração e Documentação
Depuração e Documentação

Depuração e Documentação

Depuração e Documentação
Depuração e Documentação
Depuração e Documentação
Depuração e Documentação
Depuração e Documentação Sempre !!!: Documentação Documentação do código serve principalmente quando outro

Depuração e Documentação

Depuração e Documentação Sempre !!!: Documentação Documentação do código serve principalmente quando outro
Depuração e Documentação Sempre !!!: Documentação Documentação do código serve principalmente quando outro

Sempre !!!:

Documentação

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

de um código pode ser feita com: // - quando for uma linha /** **/ -
Depuração e Documentação #include <iostream> using namespace std; /** Autor: Thomás da Costa Data de

Depuração e Documentação

Depuração e Documentação #include <iostream> using namespace std; /** Autor: Thomás da Costa Data de
Depuração e Documentação #include <iostream> using namespace std; /** Autor: Thomás da Costa Data de

#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

que efetua o cálculo de uma progressão aritmética Bloco de comentário Descritivo: Progressão aritmética é

Bloco de comentário

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

}

}

// Imprime valor na tela da PA cout << resultadoPa << "\n" ; } } Comentário

Comentário em linha

// Imprime valor na tela da PA cout << resultadoPa << "\n" ; } } Comentário
Depuração e Documentação Resumo - Depuração é o processo de identificação erros dentro de uma

Depuração e Documentação

Depuração e Documentação Resumo - Depuração é o processo de identificação erros dentro de uma aplicação
Depuração e Documentação Resumo - Depuração é o processo de identificação erros dentro de uma aplicaçã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

a linha - Bugs são defeitos no programa - Documentação é importante quando vamos efetuar a
a linha - Bugs são defeitos no programa - Documentação é importante quando vamos efetuar a
Estruturas, Uniões e Enumeração Tipos definidos pelo Usuário Definição: Quando precisamos definir novos nomes a

Estruturas, Uniões e Enumeração

Estruturas, Uniões e Enumeração Tipos definidos pelo Usuário Definição: Quando precisamos definir novos nomes a
Estruturas, Uniões e Enumeração Tipos definidos pelo Usuário Definição: Quando precisamos definir novos nomes a

Tipos definidos pelo Usuário

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.

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

}

(val, "Programação Estruturada II" ); cout << "Tipo do usuário:" << val; }
Arquivos ARQUIVOS

Arquivos

Arquivos ARQUIVOS
Arquivos ARQUIVOS
Arquivos ARQUIVOS

ARQUIVOS

Arquivos ARQUIVOS
Arquivos Arquivos Bem conhecido no nosso dia-a-dia: Todos os dias no nosso trabalho ou em

Arquivos

Arquivos Arquivos Bem conhecido no nosso dia-a-dia: Todos os dias no nosso trabalho ou em casa
Arquivos Arquivos Bem conhecido no nosso dia-a-dia: Todos os dias no nosso trabalho ou em casa

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

nenhum processo de armazenamento de dados. Vamos aprender a armazenar informações em arquivos textos ou de
nenhum processo de armazenamento de dados. Vamos aprender a armazenar informações em arquivos textos ou de
Arquivos Tipos de Arquivos: Arquivos Texto: armazena somente texto e caracteres. Normalmente possuem extensão txt

Arquivos

Arquivos Tipos de Arquivos: Arquivos Texto: armazena somente texto e caracteres. Normalmente possuem extensão txt
Arquivos Tipos de Arquivos: Arquivos Texto: armazena somente texto e caracteres. Normalmente possuem extensão txt

Tipos de Arquivos:

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

armazenar textos, imagens, planilhas e outros tipos de informações. Algumas extensões conhecidas: pdf, doc, xls, gif
armazenar textos, imagens, planilhas e outros tipos de informações. Algumas extensões conhecidas: pdf, doc, xls, gif
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++: Include da biblioteca de arquivos #include <fstream> Variável

Arquivos

Arquivos Arquivos Criando arquivos textos em C++: Include da biblioteca de arquivos #include <fstream> Variável
Arquivos Arquivos Criando arquivos textos em C++: Include da biblioteca de arquivos #include <fstream> Variável

Arquivos Criando arquivos textos em C++:

Arquivos Arquivos Criando arquivos textos em C++: Include da biblioteca de arquivos #include <fstream> Variável

Include da biblioteca de arquivos

#include <fstream>

da biblioteca de arquivos #include <fstream> Variável do arquivo ofstream ofs ; ofs.open(

Variável do arquivo

ofstream ofs;

ofs.open("ola_mundo.txt", ios::out );

Nome do arquivo

arquivo ofstream ofs ; ofs.open( "ola_mundo.txt" , ios :: out ); Nome do arquivo Formato de

Formato de abertura do arquivo

arquivo ofstream ofs ; ofs.open( "ola_mundo.txt" , ios :: out ); Nome do arquivo Formato de
arquivo ofstream ofs ; ofs.open( "ola_mundo.txt" , ios :: out ); Nome do arquivo Formato de
#include <iostream> #include <fstream> #include <strings.h> using namespace std; void

#include <iostream>

#include <fstream> #include <strings.h>

using namespace std;

void gravar_arquivo();

Exemplo 1
Exemplo 1

O tipo string é semelhante a um vetor de char, ou seja, armazena um conjunto de caracteres

int main()

{

}

ou seja, armazena um conjunto de caracteres int main () { } gravar_arquivo(); void gravar_arquivo ()

gravar_arquivo();

void gravar_arquivo()

{

string valor;

valor = "Ola Mundo";

ofstream ofs;

ofs.open("ola_mundo.txt", ios::out );

ofs << valor;

ofs ; ofs.open( "ola_mundo.txt" , ios :: out ); ofs << valor; ofs.close (); } Grava

ofs.close();
}

Grava um texto no arquivo

ofs ; ofs.open( "ola_mundo.txt" , ios :: out ); ofs << valor; ofs.close (); } Grava
Arquivos Arquivos Lendo arquivos textos em C++: Include da biblioteca de arquivos Variável do arquivo

Arquivos

Arquivos Arquivos Lendo arquivos textos em C++: Include da biblioteca de arquivos Variável do arquivo #include
Arquivos Arquivos Lendo arquivos textos em C++: Include da biblioteca de arquivos Variável do arquivo #include

Arquivos

Lendo arquivos textos em C++:

Arquivos Arquivos Lendo arquivos textos em C++: Include da biblioteca de arquivos Variável do arquivo #include

Include da biblioteca de arquivos

Variável do arquivo

#include <fstream>

ifstream ifs; ifs.open("ola_mundo.txt", ios:: in );

Nome do arquivo

ifstream ifs ; ifs.open( "ola_mundo.txt" , ios :: in ); Nome do arquivo Formato de abertura

Formato de abertura do arquivo

ifstream ifs ; ifs.open( "ola_mundo.txt" , ios :: in ); Nome do arquivo Formato de abertura
ifstream ifs ; ifs.open( "ola_mundo.txt" , ios :: in ); Nome do arquivo Formato de abertura
#include <iostream> #include <fstream> #include <strings.h> using namespace std; void

#include <iostream>

#include <fstream> #include <strings.h>

using namespace std;

void ler_arquivo();

using namespace std; void ler_arquivo (); Exemplo 2 int main () { } ler_arquivo(); void ler_arquivo

Exemplo 2

using namespace std; void ler_arquivo (); Exemplo 2 int main () { } ler_arquivo(); 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;

possivel abrir o arquivo" << endl; return ; } Efetua a leitura de uma linha no

}

Efetua a leitura de uma linha no arquivo

getline(ifs, valor); cout << "Conteúdo do Arquivo:" << valor << endl; ifs.close();

}

getline(ifs, valor); cout << "Conteúdo do Arquivo:" << valor << endl; ifs.close(); }
Arquivos Lembrete: Arquivos Sempre que um arquivo for aberto para leitura ou escrita, o mesmo

Arquivos

Arquivos Lembrete: Arquivos Sempre que um arquivo for aberto para leitura ou escrita, o mesmo deve
Arquivos Lembrete: Arquivos Sempre que um arquivo for aberto para leitura ou escrita, o mesmo deve

Lembrete:

Arquivos

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.

programas e não ocupar recursos do sistema operacional. Utilizar o comando close() dos objetos ofstream e

Utilizar o comando close() dos objetos ofstream e ifstream !!!

programas e não ocupar recursos do sistema operacional. Utilizar o comando close() dos objetos ofstream e
Arquivos Arquivos Novos tipos e comandos: string: novo tipo de variável, semelhante a um vetor

Arquivos

Arquivos Arquivos Novos tipos e comandos: string: novo tipo de variável, semelhante a um vetor de
Arquivos Arquivos Novos tipos e comandos: string: novo tipo de variável, semelhante a um vetor de

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

no disco. Exemplo de problemas: falta de espaço em disco, diretório não existente e etc Programação
#include <iostream> #include <fstream> #include <strings.h> using namespace std; void

#include <iostream> #include <fstream> #include <strings.h>

using namespace std;

void gravar_arquivo();

Exemplo 3
Exemplo 3

int main()

{

gravar_arquivo();

}

Lendo valores a partir do teclado

gravar_arquivo(); } Lendo valores a partir do teclado void gravar_arquivo () { int valor_1; double valor_2;

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

Gravando os valores sequencialmente

, ios :: out ); Gravando os valores sequencialmente ofs << valor_1 << endl; ofs <<

ofs << valor_1 << endl; ofs << valor_2 << endl; ofs << valor_3 << endl; ofs << valor_4 << endl; ofs.close();

}

valor_2 << endl; ofs << valor_3 << endl; ofs << valor_4 << endl; ofs.close(); }
#include <iostream> #include <fstream> #include <strings.h> using namespace std; void

#include <iostream>

#include <fstream> #include <strings.h>

using namespace std;

void ler_arquivo()

{

Exemplo 4
Exemplo 4

void ler_arquivo();

int main()

{

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

{ Lendo os valores sequencialmente cout << "Não foi possivel abrir o arquivo" << endl;
{
Lendo os valores sequencialmente
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();

}

<< valor_2 << "," << valor_3 << "," << valor_4; ifs.close(); }
Arquivos Arquivos Formas de abertura de um arquivo: Quando trabalhamos com arquivos, existem várias formas

Arquivos

Arquivos Arquivos Formas de abertura de um arquivo: Quando trabalhamos com arquivos, existem várias formas de
Arquivos Arquivos Formas de abertura de um arquivo: Quando trabalhamos com arquivos, existem várias formas de

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:

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

ios::app Insere valores no fim do arquivo ios::trunc Apaga o conteúdo do arquivo e substitui por
#include <iostream> #include <fstream> #include <strings.h> using namespace std; Exemplo 5

#include <iostream>

#include <fstream>

#include <strings.h>

using namespace std;

Exemplo 5
Exemplo 5

void gravar_fim_arquivo();

Abre o arquivo para escrita e insere valores no final do arquivo

int main() {

gravar_fim_arquivo();

}

void gravar_fim_arquivo()

{

() { gravar_fim_arquivo(); } void gravar_fim_arquivo () { string valor; valor = "Nova linha no arquivo"

string valor;

valor = "Nova linha no arquivo";

ofstream ofs; ofs.open("arquivo_linhas.txt", ios:: out | ios::app); ofs << valor << endl; ofs.close();

}

"arquivo_linhas.txt" , ios :: out | ios :: app ); ofs << valor << endl; ofs.close();
Arquivos Arquivos Lendo um arquivo com várias linhas: Normalmente um arquivo texto possui várias linhas

Arquivos

Arquivos Arquivos Lendo um arquivo com várias linhas: Normalmente um arquivo texto possui várias linhas de
Arquivos Arquivos Lendo um arquivo com várias linhas: Normalmente um arquivo texto possui várias linhas de

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

um programa para ler um arquivo, não temos ideia do seu tamanho. Para efetuarmos a leitura

tamanho. Para efetuarmos a leitura do arquivo até o seu fim, utilizamos o comando getline dentro de uma instrução while.

O comando getline busca sempre o fim de linha

o seu fim, utilizamos o comando getline dentro de uma instrução while. O comando getline busca
#include <iostream> #include <fstream> #include <strings.h> using namespace std; void

#include <iostream> #include <fstream>

#include <strings.h>

using namespace std;

void gravar_arquivo();

int main()

using namespace std; void gravar_arquivo (); int main () Exemplo 6 { } Criando um arquivo

Exemplo 6

std; void gravar_arquivo (); int main () Exemplo 6 { } Criando um arquivo com várias

{

}

Criando um arquivo com várias linhas. No nosso caso, 3 linhas.

gravar_arquivo();

várias linhas. No nosso caso, 3 linhas. gravar_arquivo(); void gravar_arquivo () { string valor; ofstream ofs;

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();

}

"As funções são reutilizáveis dentro de um programa." ; ofs << valor << endl; ofs.close(); }
#include <iostream> #include <fstream> #include <strings.h> using namespace std; void

#include <iostream> #include <fstream>

#include <strings.h>

using namespace std;

void ler_arquivo();

int main()

using namespace std; void ler_arquivo (); int main () Exemplo 7 { } ler_arquivo(); void ler_arquivo

Exemplo 7

namespace std; void ler_arquivo (); int main () Exemplo 7 { } ler_arquivo(); void ler_arquivo ()

{

}

ler_arquivo();

void ler_arquivo()

{

}

string linha;

ifstream ifs; ifs.open("arquivo_linhas.txt", ios::in);

if (!ifs.is_open())

{

Utilizando getline para efetuar a leitura de

uma linha. Enquanto existir linha no

arquivo, a leitura será efetuada

Enquanto existir linha no arquivo, a leitura será efetuada cout << "Não foi possivel abrir o

cout << "Não foi possivel abrir o arquivo" << endl; return;

}

while (getline(ifs, linha))

{

}

ifs.close();

cout << linha << endl;

<< endl; return ; } while (getline(ifs, linha)) { } ifs.close(); cout << linha << endl;
Arquivos Arquivos Gravando estruturas em arquivo: Até agora vimos como gravar informações no formato texto.

Arquivos

Arquivos Arquivos Gravando estruturas em arquivo: Até agora vimos como gravar informações no formato texto. Neste
Arquivos Arquivos Gravando estruturas em arquivo: Até agora vimos como gravar informações no formato texto. Neste

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

Vamos ver a nova forma de gravação em arquivos !!!

um tipo de variável, sem precisar usar o ofstream e o ifstream Vamos ver a nova
Arquivos Arquivos Escrevendo/Lendo arquivos textos e binários em C++: Include da biblioteca de arquivos Variável

Arquivos

Arquivos Arquivos Escrevendo/Lendo arquivos textos e binários em C++: Include da biblioteca de arquivos Variável do
Arquivos Arquivos Escrevendo/Lendo arquivos textos e binários em C++: Include da biblioteca de arquivos Variável do

Arquivos

Escrevendo/Lendo arquivos textos e binários em C++:

Include da biblioteca de arquivos Variável do arquivo
Include da biblioteca de arquivos
Variável do arquivo

#include <fstream>

fstream fst;

fst.open("registros.dat",

Nome do arquivo

ios:: in | ios:: out | ios:: app | ios::binary );

Formato de abertura do arquivo

, Nome do arquivo ios :: in | ios :: out | ios :: app |
, Nome do arquivo ios :: in | ios :: out | ios :: app |
Arquivos Arquivos Gravando uma estrutura em um arquivo: Comando para gravação “ Cast ” da

Arquivos

Arquivos Arquivos Gravando uma estrutura em um arquivo: Comando para gravação “ Cast ” da estrutura
Arquivos Arquivos Gravando uma estrutura em um arquivo: Comando para gravação “ Cast ” da estrutura

Arquivos Gravando uma estrutura em um arquivo:

Comando para gravação

uma estrutura em um arquivo: Comando para gravação “ Cast ” da estrutura para char fst.write
uma estrutura em um arquivo: Comando para gravação “ Cast ” da estrutura para char fst.write

Cast” da estrutura para char

fst.write((char *)&alu, sizeof(alu));

Tamanho da estrutura que será gravada

“ Cast ” da estrutura para char fst.write (( char *)&alu , sizeof (alu)); Tamanho da
#include <iostream> #include <fstream> #include <strings.h> #include <limits> using

#include <iostream> #include <fstream> #include <strings.h> #include <limits>

using namespace std;

#include <limits> using namespace std; Exemplo 8 struct alunos { long id ; char nome [255];

Exemplo 8

#include <limits> using namespace std; Exemplo 8 struct alunos { long id ; char nome [255];

struct alunos

{

long id; char nome[255]; char ra[30]; int idade;

};

void gravar_arquivo_registros();

int main()

{

gravar_arquivo_registros();

}

Gravando uma estrutura no

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;

arquivo return; } fst.write((char *)&alu, sizeof(alu)); fst.close();
arquivo
return;
}
fst.write((char *)&alu, sizeof(alu));
fst.close();

}

abrir o arquivo" << endl; arquivo return; } fst.write((char *)&alu, sizeof(alu)); fst.close(); }
Arquivos Arquivos Lendo uma estrutura em um arquivo: Comando para leitura “ Cast ” da

Arquivos

Arquivos Arquivos Lendo uma estrutura em um arquivo: Comando para leitura “ Cast ” da estrutura
Arquivos Arquivos Lendo uma estrutura em um arquivo: Comando para leitura “ Cast ” da estrutura

Arquivos Lendo uma estrutura em um arquivo:

Comando para leitura

Lendo uma estrutura em um arquivo: Comando para leitura “ Cast ” da estrutura para char
Lendo uma estrutura em um arquivo: Comando para leitura “ Cast ” da estrutura para char

Cast” da estrutura para char

fst.read((char *)&alu,sizeof(alu))

Tamanho da estrutura que será lida

leitura “ Cast ” da estrutura para char fst.read(( char *)&alu, sizeof (alu)) Tamanho da estrutura
#include <iostream> #include <fstream> #include <strings.h> #include <limits> Exemplo

#include <iostream> #include <fstream>

#include <strings.h>

#include <limits>

#include <strings.h> #include <limits> Exemplo 9 using namespace std; struct alunos { void

Exemplo 9

<strings.h> #include <limits> Exemplo 9 using namespace std; struct alunos { void

using namespace std;

struct alunos

{

void ler_arquivo_registros()

{

alunos alu;

long id; char nome[255]; char ra[30]; int idade;

};

void ler_arquivo_registros();

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;

}

int main() while (fst.read((char *)&alu,sizeof(alu))) { { ler_arquivo_registros(); } cout <<
int main()
while (fst.read((char *)&alu,sizeof(alu)))
{
{
ler_arquivo_registros();
}
cout << "************************" << endl;
cout << "Nome:" << alu.nome << endl;
cout << "RA:" << alu.ra << endl;
cout << "Idade:" << alu.idade << endl;
}
Lendo uma estrutura do
arquivo
fst.close();

}

cout << "Idade:" << alu.idade << endl; } Lendo uma estrutura do arquivo fst.close(); }
Arquivos Resumo: Arquivos - Existem dois formatos de arquivos: texto e binário - Utilizamos o

Arquivos

Arquivos Resumo: Arquivos - Existem dois formatos de arquivos: texto e binário - Utilizamos o tipo
Arquivos Resumo: Arquivos - Existem dois formatos de arquivos: texto e binário - Utilizamos o tipo

Resumo:

Arquivos

- 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

- Para efetuar a leitura de um arquivo com várias linhas utilizamos o getline dentro de
Ponteiros PONTEIROS

Ponteiros

Ponteiros PONTEIROS
Ponteiros PONTEIROS
Ponteiros PONTEIROS

PONTEIROS

Ponteiros PONTEIROS
Ponteiros O que é: Ponteiros É um tipo de variável que armazena um endereço de

Ponteiros

Ponteiros O que é: Ponteiros É um tipo de variável que armazena um endereço de memoria
Ponteiros O que é: Ponteiros É um tipo de variável que armazena um endereço de memoria

O que é:

Ponteiros

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

de memoria referente a uma outra variável. O ponteiro não armazena diretamente um valor como os
de memoria referente a uma outra variável. O ponteiro não armazena diretamente um valor como os
Ponteiros Mais detalhes: Ponteiros - O entendimento de ponteiros é complexo - São utilizados quando

Ponteiros

Ponteiros Mais detalhes: Ponteiros - O entendimento de ponteiros é complexo - São utilizados quando desejamos
Ponteiros Mais detalhes: Ponteiros - O entendimento de ponteiros é complexo - São utilizados quando desejamos

Mais detalhes:

Ponteiros

- 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

estruturas complexas, como lista encadeadas e árvores binárias - Atuar com desenvolvimento de aplicações complexas
estruturas complexas, como lista encadeadas e árvores binárias - Atuar com desenvolvimento de aplicações complexas
estruturas complexas, como lista encadeadas e árvores binárias - Atuar com desenvolvimento de aplicações complexas
Ponteiros Operadores: Ponteiros Para operação com ponteiros, utilizamos dois operadores unários: Operador

Ponteiros

Ponteiros Operadores: Ponteiros Para operação com ponteiros, utilizamos dois operadores unários: Operador
Ponteiros Operadores: Ponteiros Para operação com ponteiros, utilizamos dois operadores unários: Operador

Operadores:

Ponteiros

Para operação com ponteiros, utilizamos dois operadores unários:

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

Utilizado para retornar o endereço de memória da variável Vamos ver como declarar uma variável do
Ponteiros Ponteiros Declarando uma variável do tipo ponteiro: Nome da variável Tipo da variável Operador

Ponteiros

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

Ponteiros Declarando uma variável do tipo ponteiro:

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

Nome da variável

Tipo da variável Operador unário
Tipo da variável
Operador unário

int *ptr;

Ponteiros Declarando uma variável do tipo ponteiro: Nome da variável Tipo da variável Operador unário int
Ponteiros Declarando uma variável do tipo ponteiro: Nome da variável Tipo da variável Operador unário int
#include <iostream> Exemplo 1 using namespace std; int main() { int *ptr; Declarando um ponteiro
#include <iostream> Exemplo 1 using namespace std; int main() { int *ptr; Declarando um ponteiro

#include <iostream>

Exemplo 1

#include <iostream> Exemplo 1 using namespace std; int main() { int *ptr; Declarando um ponteiro }

using namespace std;

#include <iostream> Exemplo 1 using namespace std; int main() { int *ptr; Declarando um ponteiro }

int main()

{

int *ptr;

Declarando um ponteiro

}

cout << ptr << endl;

um ponteiro } cout << ptr << endl; Exibe o endereço da variável, neste caso, nenhum

Exibe o endereço da variável, neste caso, nenhum endereço foi atribuído

} cout << ptr << endl; Exibe o endereço da variável, neste caso, nenhum endereço foi
Ponteiros Ponteiros Declaração e atribuição de ponteiros: int *ptr; int valor; Variável ponteiro valor =

Ponteiros

Ponteiros Ponteiros Declaração e atribuição de ponteiros: int *ptr; int valor; Variável ponteiro valor = 1500;
Ponteiros Ponteiros Declaração e atribuição de ponteiros: int *ptr; int valor; Variável ponteiro valor = 1500;

Ponteiros Declaração e atribuição de ponteiros:

int *ptr;

Declaração e atribuição de ponteiros: int *ptr; int valor; Variável ponteiro valor = 1500; ptr =

int valor;

Variável ponteiro

valor = 1500; ptr = &valor;

int *ptr; int valor; Variável ponteiro valor = 1500; ptr = &valor; Atribuindo o endereço de

Atribuindo

o

endereço

de

memória

int *ptr; int valor; Variável ponteiro valor = 1500; ptr = &valor; Atribuindo o endereço de
#include <iostream> using namespace std; Exemplo 2 valor int main() int valor; int *ptr; ptr

#include <iostream>

#include <iostream> using namespace std; Exemplo 2 valor int main() int valor; int *ptr; ptr 0x23fe44

using namespace std;

Exemplo 2

#include <iostream> using namespace std; Exemplo 2 valor int main() int valor; int *ptr; ptr 0x23fe44

valor

<iostream> using namespace std; Exemplo 2 valor int main() int valor; int *ptr; ptr 0x23fe44 1500

int main()

int valor; int *ptr; valor;
int valor; int *ptr; int *ptr;

ptr

Exemplo 2 valor int main() int valor; int *ptr; ptr 0x23fe44 1500 0x23fe44 0x23fe44 valor =

0x23fe44

1500 0x23fe44 0x23fe44
1500
0x23fe44
0x23fe44

valor = 1500;valor; int *ptr; ptr 0x23fe44 1500 0x23fe44 0x23fe44 ptr = &valor; cout << ptr << endl;

ptr = &valor; = &valor;

cout << ptr << endl;

cout << *ptr << endl;

}

0x23fe48

0x23fe48

0x23fe48

0x23fe48
ptr = &valor; cout << ptr << endl; cout << * ptr << endl; } 0x23fe48
Ponteiros Ponteiros Mais detalhes: - Ponteiro armazena o endereço de memória - O operador &

Ponteiros

Ponteiros Ponteiros Mais detalhes: - Ponteiro armazena o endereço de memória - O operador & mostra
Ponteiros Ponteiros Mais detalhes: - Ponteiro armazena o endereço de memória - O operador & mostra
Ponteiros Ponteiros Mais detalhes: - Ponteiro armazena o endereço de memória - O operador & mostra

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

da variável de ponteiro é exibido o valor atribuído no endereço de memória referente. Vamos ver
#include <iostream> using namespace std; Exemplo 3 int main() { valor 0x23fe44 ptr 0x23fe48 total

#include <iostream>

#include <iostream> using namespace std; Exemplo 3 int main() { valor 0x23fe44 ptr 0x23fe48 total int

using namespace std;

Exemplo 3

#include <iostream> using namespace std; Exemplo 3 int main() { valor 0x23fe44 ptr 0x23fe48 total int

int main()

{

valor

using namespace std; Exemplo 3 int main() { valor 0x23fe44 ptr 0x23fe48 total int valor; int
using namespace std; Exemplo 3 int main() { valor 0x23fe44 ptr 0x23fe48 total int valor; int

0x23fe44

ptr

namespace std; Exemplo 3 int main() { valor 0x23fe44 ptr 0x23fe48 total int valor; int *ptr;
namespace std; Exemplo 3 int main() { valor 0x23fe44 ptr 0x23fe48 total int valor; int *ptr;

0x23fe48

total

Exemplo 3 int main() { valor 0x23fe44 ptr 0x23fe48 total int valor; int *ptr; int total;

int valor; int *ptr; valor;
int valor; int *ptr; int *ptr;

int total; total;

ptr 0x23fe48 total int valor; int *ptr; int total; 1600 0x23fe44 0x23fe44 0x23fe48 1600 valor =
1600
1600
0x23fe44 0x23fe44 0x23fe48 1600
0x23fe44
0x23fe44
0x23fe48
1600

valor = 1600; ptr = &valor; total = *ptr;
ptr = &valor; valor = 1600; total = *ptr;
total = *ptr;valor = 1600; ptr = &valor;

cout << *ptr << endl;

cout << total << endl;

}

0x23fe40

0x23fe40

total = *ptr; cout << *ptr << endl; cout << total << endl; } 0x23fe40 0x23fe40
Ponteiros Importante: Ponteiros A atribuição de valores para ponteiros, deve ser do mesmo tipo. Quando

Ponteiros

Ponteiros Importante: Ponteiros A atribuição de valores para ponteiros, deve ser do mesmo tipo. Quando as
Ponteiros Importante: Ponteiros A atribuição de valores para ponteiros, deve ser do mesmo tipo. Quando as

Importante:

Ponteiros

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.

para ponteiros, deve ser do mesmo tipo. Quando as variáveis são de tipos diferentes, vamos ter
para ponteiros, deve ser do mesmo tipo. Quando as variáveis são de tipos diferentes, vamos ter
#include <iostream> using namespace std; Exemplo 4 int main() { // PROGRAMA COM ERRO NAO

#include <iostream>

#include <iostream> using namespace std; Exemplo 4 int main() { // PROGRAMA COM ERRO NAO COMPILA

using namespace std;

Exemplo 4

#include <iostream> using namespace std; Exemplo 4 int main() { // PROGRAMA COM ERRO NAO COMPILA

int main()

{

// PROGRAMA COM ERRO NAO COMPILA !!!! int *ptr_inteiro; double valor;

ERRO NAO COMPILA !!!! int *ptr_inteiro; double valor; valor = 345.76; ptr_inteiro = &valor; ERRO !!!

valor = 345.76; ptr_inteiro = &valor;

ERRO !!!

cout << *ptr_inteiro << endl;

}

double valor; valor = 345.76; ptr_inteiro = &valor; ERRO !!! cout << *ptr_inteiro << endl; }
Ponteiros Ponteiros Conversão de valores: Para atribuir ponteiros de tipos diferentes, utilizamos um conceito chamado

Ponteiros

Ponteiros Ponteiros Conversão de valores: Para atribuir ponteiros de tipos diferentes, utilizamos um conceito chamado
Ponteiros Ponteiros Conversão de valores: Para atribuir ponteiros de tipos diferentes, utilizamos um conceito chamado

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.

as variáveis de um tipo são convertido em outro tipo. Muitas vezes esta conversão não ocorre
as variáveis de um tipo são convertido em outro tipo. Muitas vezes esta conversão não ocorre
Ponteiros Ponteiros Conversão de valores: int *ptr_inteiro; double valor; ptr_inteiro = ( int *)&valor;

Ponteiros

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

Ponteiros

Conversão de valores:

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

int *ptr_inteiro; double valor;

ptr_inteiro = (int *)&valor;

Conversão de valores

Conversão de valores: int *ptr_inteiro; double valor; ptr_inteiro = ( int *)&valor; Conversão de valores
Ponteiros Ponteiros Conversão de valores: Temos um pequeno problema quando existe a conversão de ponteiros

Ponteiros

Ponteiros Ponteiros Conversão de valores: Temos um pequeno problema quando existe a conversão de ponteiros de
Ponteiros Ponteiros Conversão de valores: Temos um pequeno problema quando existe a conversão de ponteiros de

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.

Temos um pequeno problema quando existe a conversão de ponteiros de tipos diferentes. Vamos ver no
Temos um pequeno problema quando existe a conversão de ponteiros de tipos diferentes. Vamos ver no
#include <iostream> Exemplo 5 using namespace std; int main() { double valor; int *ptr_inteiro;  

#include <iostream>

#include <iostream> Exemplo 5 using namespace std; int main() { double valor; int *ptr_inteiro;  

Exemplo 5

#include <iostream> Exemplo 5 using namespace std; int main() { double valor; int *ptr_inteiro;  

using namespace std;

int main()

{

double valor; int *ptr_inteiro; valor;
double valor; int *ptr_inteiro; int *ptr_inteiro;

 

valor

ptr_inteiro

 
  0x23fe40   0x23fe48
 

0x23fe40

 

0x23fe48

  0x23fe40   0x23fe48
345.76 0x23fe40 0x23fe40 0x23fe48

345.76

0x23fe40

0x23fe40

0x23fe48

345.76 0x23fe40 0x23fe40 0x23fe48

valor = 345.76; ptr_inteiro = ( int *)&valor;
ptr_inteiro valor = 345.76; = ( int *)&valor; = (int *)&valor;

valor = 345.76; ptr_inteiro = ( int *)&valor; Valor exibido: -171798692 cout << *ptr_inteiro

Valor exibido:

-171798692

= ( int *)&valor; Valor exibido: -171798692 cout << *ptr_inteiro << endl; } Valor

cout << *ptr_inteiro << endl;

}

Valor incorreto exibido pelo ponteiro !!!

#include <iostream> using namespace std; Exemplo 6 Conversão não funciona completamente int main() { int

#include <iostream>

#include <iostream> using namespace std; Exemplo 6 Conversão não funciona completamente int main() { int

using namespace std;

Exemplo 6

#include <iostream> using namespace std; Exemplo 6 Conversão não funciona completamente int main() { int

Conversão não funciona completamente

int main()

{

6 Conversão não funciona completamente int main() { int *ptr_inteiro; double valor_1; double valor_2; São

int *ptr_inteiro;

double valor_1;

double valor_2;

São exibidos valores errados

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;

}

valor_1 << endl; cout << *ptr_inteiro << endl; cout << valor_2 << endl; }
Ponteiros Ponteiros Atribuição de valores: Podemos atribuir um valor diretamente para um ponteiro. Para isso

Ponteiros

Ponteiros Ponteiros Atribuição de valores: Podemos atribuir um valor diretamente para um ponteiro. Para isso utilizamos
Ponteiros Ponteiros Atribuição de valores: Podemos atribuir um valor diretamente para um ponteiro. Para isso utilizamos

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.

Variável do tipo ponteiro

o operador * antes do nome da variável do tipo ponteiro. Variável do tipo ponteiro *ptr

*ptr = 999;

o operador * antes do nome da variável do tipo ponteiro. Variável do tipo ponteiro *ptr

Atribuindo um valor

o operador * antes do nome da variável do tipo ponteiro. Variável do tipo ponteiro *ptr
#include <iostream> Exemplo 7 using namespace std; ptr x int main() int *ptr; int x;

#include <iostream>

#include <iostream> Exemplo 7 using namespace std; ptr x int main() int *ptr; int x; ptr
#include <iostream> Exemplo 7 using namespace std; ptr x int main() int *ptr; int x; ptr

Exemplo 7

using namespace std;

ptr

<iostream> Exemplo 7 using namespace std; ptr x int main() int *ptr; int x; ptr =

x

<iostream> Exemplo 7 using namespace std; ptr x int main() int *ptr; int x; ptr =

int main()

int *ptr; *ptr;

int x; x;

ptr = &x; *ptr = 999; = &x;
*ptr = 999;ptr = &x;

int main() int *ptr; int x; ptr = &x; *ptr = 999; 0x23fe48 0x23fe44 0x23fe44 0x23fe48

0x23fe48

0x23fe44

*ptr; int x; ptr = &x; *ptr = 999; 0x23fe48 0x23fe44 0x23fe44 0x23fe48 999 0x23fe44 cout
0x23fe44 0x23fe48 999
0x23fe44
0x23fe48
999

0x23fe44

cout << &x << endl; cout << ptr << endl;

cout << *ptr << endl;

}

cout << &x << endl; cout << ptr << endl; cout << *ptr << endl; }
Ponteiros Ponteiros Operação com ponteiros: Em ponteiros, possuímos operações de incremento e decremento, tanto para

Ponteiros

Ponteiros Ponteiros Operação com ponteiros: Em ponteiros, possuímos operações de incremento e decremento, tanto para
Ponteiros Ponteiros Operação com ponteiros: Em ponteiros, possuímos operações de incremento e decremento, tanto para

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.

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

da variável. Por exemplo: se uma variável for do tipo inteiro, o ponteiro será incrementado e
Ponteiros Ponteiros Como incrementar e decrementar um ponteiro: No exemplo abaixo, a posição de memória

Ponteiros

Ponteiros Ponteiros Como incrementar e decrementar um ponteiro: No exemplo abaixo, a posição de memória será
Ponteiros Ponteiros Como incrementar e decrementar um ponteiro: No exemplo abaixo, a posição de memória será

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.

Incremento de ponteiro

int *ptr;

da variável inteira. Incremento de ponteiro int *ptr; ptr ++; Somente o endereço do ponteiro atribuído

ptr++;

Somente o endereço do ponteiro atribuído na variável será incrementado ou decrementado

ptr--;

Somente o endereço do ponteiro atribuído na variável será incrementado ou decrementado p tr-- ; Decremento

Decremento de ponteiro

Somente o endereço do ponteiro atribuído na variável será incrementado ou decrementado p tr-- ; Decremento
Ponteiros Ponteiros Como incrementar e decrementar o valor de um ponteiro: No exemplo abaixo, o

Ponteiros

Ponteiros Ponteiros Como incrementar e decrementar o valor de um ponteiro: No exemplo abaixo, o valor
Ponteiros Ponteiros Como incrementar e decrementar o valor de um ponteiro: No exemplo abaixo, o valor

Ponteiros Como incrementar e decrementar o valor de um ponteiro:

No exemplo abaixo, o valor de um ponteiro é incrementado e decrementado.

int *ptr;

Decremento do valor do ponteiro

Incremento do valor do ponteiro

do valor do ponteiro Incremento do valor do ponteiro (* ptr)++; (*ptr)--; O valor atribuído na
do valor do ponteiro Incremento do valor do ponteiro (* ptr)++; (*ptr)--; O valor atribuído na

(*ptr)++;

(*ptr)--;

O valor atribuído na posição de

memória do ponteiro, será

incrementado ou decrementado

Exemplo 8 #include <iostream> using namespace std; int main() { int *ptr; int x; ptr
Exemplo 8 #include <iostream> using namespace std; int main() { int *ptr; int x; ptr

Exemplo 8

Exemplo 8 #include <iostream> using namespace std; int main() { int *ptr; int x; ptr =

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

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

(*ptr)++; cout << "Inc. valor:" << *ptr << endl;

(*ptr)--; cout << "Dec. valor:" << *ptr << endl;
}

<< *ptr << endl; (*ptr)--; cout << "Dec. valor:" << *ptr << endl; }
#include <iostream> using namespace std; int main() int *ptr; int x; ptr = &x; *ptr

#include <iostream>

#include <iostream> using namespace std; int main() int *ptr; int x; ptr = &x; *ptr =

using namespace std;

int main()

int *ptr; int x; *ptr;
int *ptr; int x; int x;

ptr = &x;using namespace std; int main() int *ptr; int x; *ptr = 999; ptr++; ptr--; (*ptr)++; (*ptr)--;

*ptr = 999;std; int main() int *ptr; int x; ptr = &x; ptr++; ptr--; (*ptr)++; (*ptr)--;   ptr

ptr++; int main() int *ptr; int x; ptr = &x; *ptr = 999; ptr--; (*ptr)++; (*ptr)--;  
ptr++;

ptr--;

(*ptr)++;*ptr; int x; ptr = &x; *ptr = 999; ptr++; ptr--; (*ptr)--;   ptr x Exemplo

(*ptr)--;int x; ptr = &x; *ptr = 999; ptr++; ptr--; (*ptr)++;   ptr x Exemplo 8

 

ptr

x

Exemplo 8

  ptr x Exemplo 8
  0x23fe38   0x23fe34
 

0x23fe38

 

0x23fe34

  0x23fe38   0x23fe34
0x23fe34 0x23fe38 999 0x23fe34

0x23fe34

0x23fe38

999

0x23fe34

0x23fe34 0x23fe38 999 0x23fe34
0x23fe38 0x23fe38 999 0x23fe34

0x23fe38

0x23fe38

999

0x23fe34

0x23fe34 0x23fe38 999 0x23fe34

0x23fe34

0x23fe38

999
999

0x23fe34

0x23fe34

0x23fe38

1000

0x23fe34

0x23fe34 0x23fe38 1000 0x23fe34

0x23fe34

0x23fe38

999

0x23fe34

0x23fe34 0x23fe38 999 0x23fe34
0x23fe38 999 0x23fe34 0x23fe34 0x23fe38 1000 0x23fe34 0x23fe34 0x23fe38 999 0x23fe34
#include <iostream> using namespace std; int main() { Exemplo 9 double *ptr; double x; ptr

#include <iostream>

using namespace std;

int main()
{

<iostream> using namespace std; int main() { Exemplo 9 double *ptr; double x; ptr = &x;

Exemplo 9

using namespace std; int main() { Exemplo 9 double *ptr; double x; ptr = &x; *ptr

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;

Mesmo processo do programa anterior utilizando outro tipo de variável.

(*ptr)--;

cout << "Dec. valor:" << *ptr << endl;
}

utilizando outro tipo de variável. (*ptr)--; cout << "Dec. valor:" << *ptr << endl; }
Ponteiros Ponteiros Comparação de Ponteiros: Na comparação de ponteiros, utilizamos os operadores maior, menor e

Ponteiros

Ponteiros Ponteiros Comparação de Ponteiros: Na comparação de ponteiros, utilizamos os operadores maior, menor e
Ponteiros Ponteiros Comparação de Ponteiros: Na comparação de ponteiros, utilizamos os operadores maior, menor e

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.

indica se o endereço de ponteiro é igual, se está mais ou menos avançado que o
indica se o endereço de ponteiro é igual, se está mais ou menos avançado que o
Exemplo 10 #include <iostream> using namespace std; int main() { int *ptr_1; int *ptr_2; int
Exemplo 10 #include <iostream> using namespace std; int main() { int *ptr_1; int *ptr_2; int

Exemplo 10

Exemplo 10 #include <iostream> using namespace std; int main() { int *ptr_1; int *ptr_2; int x,

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

Comparação de ponteiros

ptr_2 = &x; cout << (ptr_1 == ptr_2) << endl; Comparação de ponteiros Ponteiros são iguais

Ponteiros são iguais

}

ptr_2 = &x; cout << (ptr_1 == ptr_2) << endl; Comparação de ponteiros Ponteiros são iguais
Ponteiros Vetores: Ponteiros Normalmente um vetor, pode ser representado diretamente por um ponteiro. No caso

Ponteiros

Ponteiros Vetores: Ponteiros Normalmente um vetor, pode ser representado diretamente por um ponteiro. No caso de
Ponteiros Vetores: Ponteiros Normalmente um vetor, pode ser representado diretamente por um ponteiro. No caso de

Vetores:

Ponteiros

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.

sem precisar representá-los por posições de memórias. Isto é uma característica da linguagem e do compilador.
sem precisar representá-los por posições de memórias. Isto é uma característica da linguagem e do compilador.
#include <iostream> #include <strings.h> using namespace std; Exemplo 11 int main() { char

#include <iostream> #include <strings.h>

#include <iostream> #include <strings.h> using namespace std; Exemplo 11 int main() { char

using namespace std;

Exemplo 11

<strings.h> using namespace std; Exemplo 11 int main() { char valores[100]; char *ptr; } Exibindo

int main()

{

char valores[100]; char *ptr;

}

Exibindo valor na posição do vetor

strcpy(valores, "Isto é um teste"); ptr = valores;

"Isto é um teste" ); ptr = valores; cout << valores << endl; cout <<

cout << valores << endl;

cout << ptr << endl;

ptr = (char *)"Isto é um outro teste"; cout << ptr << endl;

cout << valores[3] << endl; cout << *(ptr+3) << endl;

Ponteiros Ponteiros Operadores bit-a-bit: São operações que efetuamos diretamente com os bits de um tipo

Ponteiros

Ponteiros Ponteiros Operadores bit-a-bit: São operações que efetuamos diretamente com os bits de um tipo de
Ponteiros Ponteiros Operadores bit-a-bit: São operações que efetuamos diretamente com os bits de um tipo de

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.

Operador

Descrição

&

AND

|

OR

^

OR Exclusivo (XOR)

~

Negação

>>

Deslocamento de bit a direita

<<

Deslocamento de bit a esquerda

(XOR) ~ Negação >> Deslocamento de bit a direita << Deslocamento de bit a esquerda
Ponteiros Ponteiros Tabela verdade dos operadores bit-a-bit: Operador AND (&): Operador OR(|): p q p

Ponteiros

Ponteiros Ponteiros Tabela verdade dos operadores bit-a-bit: Operador AND (&): Operador OR(|): p q p &
Ponteiros Ponteiros Tabela verdade dos operadores bit-a-bit: Operador AND (&): Operador OR(|): p q p &

Ponteiros Tabela verdade dos operadores bit-a-bit:

Operador AND (&):

Operador OR(|):

p

q

p & q

p

q

p | q

0

0

0

0

0

0

0

1

0

0

1

1

1

0

0

1

0

1

1

1

1

1

1

1

Operador XOR(^):

p

q

p & q

0

0

0

0

1

1

1

0

1

1

1

0

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.

se for 0 se torna 1 e vice-versa. Os operadores >> e << , deslocam bit
#include <iostream> #include <strings.h> #include <stdlib.h> using namespace std; int main

#include <iostream>

#include <strings.h>

#include <stdlib.h>

using namespace std;

int main()
{

<stdlib.h> using namespace std; int main () { Exemplo 12 int *ptr_1, *ptr_2; int valor_1, valor_2;

Exemplo 12

using namespace std; int main () { Exemplo 12 int *ptr_1, *ptr_2; int valor_1, valor_2; char

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;

Converte um número para uma base específica

endl ; Converte um número para uma base específica itoa (*ptr_2, valor_convertido, 2); cout <<

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;

}

valor_convertido, 2); cout << "Operador NEG:" << valor_convertido << endl; }
Ponteiros Resumo: Ponteiros - Um ponteiro armazena uma posição de memória - Esta posição de

Ponteiros

Ponteiros Resumo: Ponteiros - Um ponteiro armazena uma posição de memória - Esta posição de memória
Ponteiros Resumo: Ponteiros - Um ponteiro armazena uma posição de memória - Esta posição de memória

Resumo:

Ponteiros

- 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

em AND, OR, XOR, NOT - Os operadores << e >> representam deslocamento de bit a
em AND, OR, XOR, NOT - Os operadores << e >> representam deslocamento de bit a
Ponteiros Ponteiros Lista Ligada Simples: É uma lista de elementos ligados em sequência. Normalmente utilizamos

Ponteiros

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

Ponteiros

Lista Ligada Simples:

É uma lista de elementos ligados em sequência. Normalmente utilizamos

estruturas para representar lista ligadas.

É uma lista de elementos ligados em sequência. Normalmente utilizamos estruturas para representar lista ligadas.
É uma lista de elementos ligados em sequência. Normalmente utilizamos estruturas para representar lista ligadas.
Ponteiros Lista Ligada Simples Mais detalhes: - São representados por estruturas - São estruturas dentro

Ponteiros

Ponteiros Lista Ligada Simples Mais detalhes: - São representados por estruturas - São estruturas dentro de
Ponteiros Lista Ligada Simples Mais detalhes: - São representados por estruturas - São estruturas dentro de

Lista Ligada Simples

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

Vamos trabalhar com inserção no fim da lista encadeada - Utilizadas para armazenar valores na memória
Vamos trabalhar com inserção no fim da lista encadeada - Utilizadas para armazenar valores na memória
Ponteiros Lista Ligada Simples Como funciona: Um elemento de uma lista, possui o endereço do

Ponteiros

Ponteiros Lista Ligada Simples Como funciona: Um elemento de uma lista, possui o endereço do próximo.
Ponteiros Lista Ligada Simples Como funciona: Um elemento de uma lista, possui o endereço do próximo.

Lista Ligada Simples

Como funciona:

Um elemento de uma lista, possui o endereço do próximo. O último elemento da

lista tem o valor NULL

Endereço de memória para o próximo elemento

1 2 3
1
2
3
da lista tem o valor NULL Endereço de memória para o próximo elemento 1 2 3

Elementos da lista ligada simples

da lista tem o valor NULL Endereço de memória para o próximo elemento 1 2 3
Ponteiros Lista Ligada Simples Exemplo: struct alunos { Próximo elemento da lista char nome[100]; int

Ponteiros

Ponteiros Lista Ligada Simples Exemplo: struct alunos { Próximo elemento da lista char nome[100]; int idade;
Ponteiros Lista Ligada Simples Exemplo: struct alunos { Próximo elemento da lista char nome[100]; int idade;

Lista Ligada Simples

Exemplo:

struct alunos

{

Próximo elemento da lista

Simples Exemplo: struct alunos { Próximo elemento da lista char nome[100]; int idade; alunos *proximo; }

char nome[100];

int idade;

alunos *proximo;

} *lista_alunos;

Exemplo: struct alunos { Próximo elemento da lista char nome[100]; int idade; alunos *proximo; } *lista_alunos;
Ponteiros Lista Ligada Simples Alocando memória: Para o nosso exemplo vamos efetuar alocação dinâmica de

Ponteiros

Ponteiros Lista Ligada Simples Alocando memória: Para o nosso exemplo vamos efetuar alocação dinâmica de memória
Ponteiros Lista Ligada Simples Alocando memória: Para o nosso exemplo vamos efetuar alocação dinâmica de memória

Lista Ligada Simples

Alocando memória:

Para o nosso exemplo vamos efetuar alocação dinâmica de memória utilizando a

palavra reservada new.

alunos *novo_aluno = new alunos;

de memória utilizando a palavra reservada new. alunos *novo_aluno = new alunos; Efetuando alocação de memória

Efetuando alocação de memória

de memória utilizando a palavra reservada new. alunos *novo_aluno = new alunos; Efetuando alocação de memória
alunos *novo_aluno = new alunos; cout << "Digite o nome do aluno:" << endl;

alunos *novo_aluno = new alunos;

alunos *novo_aluno = new alunos; cout << "Digite o nome do aluno:" << endl;

cout << "Digite o nome do aluno:" << endl; gets(novo_aluno->nome);

Exemplo 13

<< endl; gets(novo_aluno->nome); Exemplo 13 cout << "Digite a idade do aluno:"

cout << "Digite a idade do aluno:" << endl;

cin >> novo_aluno->idade;

novo_aluno->proximo = NULL;

if (lista_alunos == NULL)

lista_alunos = novo_aluno; else

{

Adicionando no final da lista

alunos *p;

p = lista_alunos;

while (p->proximo != NULL) p = p->proximo;

da lista alunos *p; p = lista_alunos; while (p->proximo != NULL) p = p->proximo; p->proximo =

p->proximo = novo_aluno;

}

da lista alunos *p; p = lista_alunos; while (p->proximo != NULL) p = p->proximo; p->proximo =
alunos *p; p = lista_alunos; if (p->proximo == NULL) { Exemplo 13 cout <<

alunos *p; p = lista_alunos;

if (p->proximo == NULL)

{

alunos *p; p = lista_alunos; if (p->proximo == NULL) { Exemplo 13 cout <<

Exemplo 13

p = lista_alunos; if (p->proximo == NULL) { Exemplo 13 cout <<