Programação estruturada - Aula 08

Prévia do material em texto

Programação Estruturada 
 
 
Prof.ª: Priscilla Abreu 
pbraz@unicarioca.edu.br 
Disciplina – Programação Estruturada 
Roteiro de aula: 
 
 
• Objetivo da aula 
– Revisão Ponteiros 
– Alocação dinâmica 
 
2 Programação Estruturada 
O que é um ponteiro? 
̶ Variável que armazena um endereço de memória. 
̶ É um tipo de variável especial que armazena o 
endereço de outra variável alocada na memória; 
̶ Tem por função apontar para um endereço de 
memória determinado. 
3 Programação Estruturada 
Operadores de manipulação de ponteiros 
Manipulação de ponteiros ocorre de duas maneiras: 
̶ Por meio do endereço de uma variável; 
̶ Por meio do conteúdo armazenado no endereço apontado 
pelo ponteiro. 
Operadores: 
̶ Operador de endereço: & 
̶ Operador de conteúdo: * 
 
 
4 Programação Estruturada 
Operadores de manipulação de ponteiros 
̶ Operador de conteúdo (*) 
5 Programação Estruturada 
Programa 
#include <stdio.h> 
int main(){ 
 char x = ‘t’, *p; 
 p = &x; 
 printf(“Conteúdo do ponteiro: %p”, p); 
 printf(“Conteúdo de x é: %c ”, x); 
 printf(“Conteúdo apontado: %d”, *p); 
} 
Memória 
x P 
t 2000 
2000 2001 2002 2003 
Busca o endereço 
armazenado 
Busca o conteúdo apontado pelo ponteiro 
Busca o conteúdo de x 
Operadores de manipulação de ponteiros 
̶ Operador de conteúdo (*) 
6 Programação Estruturada 
Programa 
#include <stdio.h> 
int main(){ 
 char x = 't', **p, *t; 
 t = &x; 
 p = &t; 
 printf("Conteúdo do ponteiro t: %p", t); 
 printf("\nConteúdo de x é: %c ", x); 
 printf("\nConteúdo do ponteiro p : %p", p); 
 printf("\nConteúdo apontado por p: %p", *p); 
 printf("\nConteúdo apontado por t: %c", **p); 
} 
Memória 
x t p 
t 2000 2002 
2000 2001 2002 2003 
Ponteiro e vetores 
Na inicialização de um ponteiro com variáveis do tipo 
vetor, matriz ou string não é preciso usar o operador &, 
pois eles já são considerados ponteiros constantes. 
Na atribuição será repassado o endereço alocado 
referente à primeira posição da variável. 
Exemplo: 
 char nome[34]; 
 char *ponteiro; 
 ponteiro = nome; 
7 Programação Estruturada 
Funções com passagem por referência 
#include <stdio.h> 
void troca( int *pa, int *pb) { 
 int tmp = *pb; 
 *pb = *pa; 
 *pa = tmp; 
} 
int main (void){ 
 int a=10, b=20; 
 troca(&a, &b); 
 printf(" a=%d b=%d\n", a, b); 
} 
8 Programação Estruturada 
 
 
ALOCAÇÃO ESTÁTICA 
X 
ALOCAÇÃO DINÂMICA 
11 Programação Estruturada 
Alocação Estática 
Alocação estática: o espaço de memória para as 
variáveis é reservado no início da execução, não 
podendo ser alterado depois. 
 int a; float n; 
 char c; 
 int b[20]; 
 
 
 
 
 
 
12 Programação Estruturada 
Alocação Estática 
A forma mais simples de estruturarmos um conjunto de 
dados é por meio de vetores. 
Definimos um vetor em C da seguinte forma: 
int v[10]; 
Esta declaração diz que v é um vetor de inteiros 
dimensionado com 10 elementos, isto é, reservamos um 
espaço de memória contínuo para armazenar 10 valores 
inteiros. 
Assim, se cada int ocupa 4 bytes, a declaração reserva um 
espaço de memória de 40 bytes. 
 
 
 
13 Programação Estruturada 
Alocação Dinâmica 
 
Processo de solicitar e utilizar memória durante a 
execução de um programa. É utilizada para que um 
programa utilize apenas a memória necessária pra sua 
execução, sem desperdícios de memória. 
15 Programação Estruturada 
Alocação Dinâmica 
Quando utilizamos? 
Quando não se sabe inicialmente, por algum motivo ou 
aplicação, quanto espaço de memória será necessário 
para o armazenamento de algum ou alguns valores. 
16 Programação Estruturada 
Alocação Dinâmica 
De acordo com a linguagem de programação há 
funções próprias para fazer o "pedido“ e “liberação” de 
memória. 
− Aloca 
− Libera 
17 Programação Estruturada 
Alocação Dinâmica 
O espaço alocado dinamicamente permanece 
reservado até que explicitamente seja liberado pelo 
programa. 
A partir do momento que liberarmos o espaço, ele 
estará disponibilizado para outros usos e não podemos 
mais acessá-lo. 
Se o programa não liberar um espaço alocado, este será 
automaticamente liberado quando a execução do 
programa terminar. 
18 Programação Estruturada 
Alocação de memória em C 
Uso da memória 
19 Programação Estruturada 
Alocação Estática x Alocação Dinâmica 
Funções de alocação de memória em C: 
 
• void * malloc(int qty_bytes_alloc); 
• void * calloc(int qtd, int size); 
• void * realloc(void * pointer, int new_size); 
• free( void * pointer); 
 
 
 
 
 
20 Programação Estruturada 
Alocação Estática x Alocação Dinâmica 
Função “sizeof”: 
– retorna o número de bytes ocupado por um tipo 
Função “free”: 
– recebe como parâmetro o ponteiro da memória a ser 
liberada 
• a função free deve receber um endereço de memória 
que tenha sido alocado dinamicamente. 
 
 
 
 
21 Programação Estruturada 
Alocação Estática x Alocação Dinâmica 
Função “malloc”: 
– recebe como parâmetro o número de bytes que 
se deseja alocar 
– retorna um ponteiro genérico para o endereço 
inicial da área de memória alocada, se houver 
espaço livre: 
– retorna um endereço nulo, se não houver espaço 
livre: 
• representado pelo símbolo NULL 
 
 
22 Programação Estruturada 
Exemplo: 
Alocação dinâmica de um vetor de inteiros com 10 
elementos 
• malloc retorna o endereço da área alocada para 
armazenar valores inteiros 
• ponteiro de inteiro recebe endereço inicial do espaço 
alocado 
 
 int *v; 
 v = (int *) malloc(10 * sizeof(int )); 
 
 
 
 
 
 
23 Programação Estruturada 
Exemplo: 
 
 
 
 
 
 
24 Programação Estruturada 
Exemplo: 
̶ v pode ser tratado como um vetor comum: 
̶ v aponta para o inicio da área alocada 
̶ v[0] acessa o espaço para o primeiro elemento 
̶ v[1] acessa o segundo 
̶ .... até v[9]. 
 
 
 
 
 
 
25 Programação Estruturada 
Exemplo: 
̶ tratamento de erro após chamada a malloc 
̶ imprime mensagem de erro 
̶ aborta o programa (com a função exit) 
 
 
 
 
 
 
26 Programação Estruturada 
Alocação Estática x Alocação Dinâmica 
Função “calloc”: 
 
void *calloc (int num, int size); 
- Aloca uma quantidade de memória igual a num * size; 
- Inicializa os espaços de memória com o valor zero; 
 
Exemplo: 
• int *v; 
• v = (int *) calloc(10 , sizeof(int )); 
 
 
 
 
27 Programação Estruturada 
Alocação Dinâmica 
̶ Exemplo: 
 
#include <stdio.h> 
int main (void){ 
 int *v, i; 
 v = (int*) malloc(15*sizeof(int)); 
 for (i=0; i<15;i++){ 
 printf("Informe um valor: "); 
 scanf("%d", &v[i]); 
 } 
 for (i=0; i<15;i++) 
 printf(“%d “,v[i]); 
 free(v); 
} 
 
 
 
 
 
28 Programação Estruturada 
Alocação Dinâmica 
̶ A partir de agora é possível fazer a seguinte 
implementação: 
 
Escreva um programa em C que solicita ao usuário um 
número n e então lê um vetor de n notas e calcula a 
média aritmética. 
– Usar alocação dinâmica do vetor 
– Liberar a memória ao final 
 
 
 
 
 
 
29 Programação Estruturada 
Exemplo 
#include <stdio.h> 
int main (void){ 
 float *v, media, soma=0.0; int qtde,i; 
 printf("Informe quantas notas que deseja armazenar: "); 
 scanf("%d", &qtde); 
 v = (float*) malloc(qtde*sizeof(float)); 
 
 
 
 
 
30 Programação Estruturada 
Exemplo (continuação) 
 for (i=0; i<qtde;i++){ 
 printf("Informe a nota: "); 
 scanf("%f", &v[i]); 
 soma = soma + v[i]; 
 } 
 media = soma / qtde; 
 printf("Média: %.1f\n", media); 
 free(v); 
} 
 
 
 
 
 
31 Programação Estruturada 
MODIFICANDO O ESPAÇO ALOCADO 
Realloc 
 
(tipo*) realloc( tipo *apontador, int novo_tamanho) 
 
int *x, i; 
x = (int *) malloc (200 * sizeof(int)); 
for (i = 0; i<200; i++){ 
 printf(“Valor: ”); scanf(&x[i]); 
} 
x = (int *) realloc (x, 400 * sizeof(int)); 
x = (int *)realloc (x, 100 * sizeof(int)); 
free(x); 
 
 
 
 
 
 
32 Programação Estruturada 
MODIFICANDO O ESPAÇO ALOCADO 
Realloc 
 
 
 
 
 
 
 
 
33 Programação Estruturada 
int *x, i; 
x = (int *) malloc (200 * sizeof(int)); 
 
for (i = 0; i<200; i++){ 
 printf(“Valor: ”); scanf(&x[i]); 
} 
 
x = (int *) realloc (x, 400 * sizeof(int)); 
 
x = (int *) realloc (x, 100 * sizeof(int)); 
 
free(x); 
AUMENTANDO O ESPAÇO ALOCADO 
#include <stdio.h> 
int main (void){ 
 float *v; 
 float soma=0.0, media; 
 int qtde,i, qt2; 
 printf("Informe quantas notas deseja armazenar:"); 
 scanf("%d", &qtde); 
 v = (float*) malloc(qtde*sizeof(float)); 
 
 
34 Programação Estruturada 
AUMENTANDO O ESPAÇO ALOCADO 
 
 for (i=0; i<qtde;i++){ 
 printf("Informe a nota: "); 
 scanf("%f", &v[i]); 
 soma = soma + v[i]; 
 } 
 media = soma / qtde; 
 printf("Média: %.1f\n", media); 
 
 
 
 
35 Programação Estruturada 
AUMENTANDO O ESPAÇO ALOCADO 
printf(“Quantidade de notas que deseja acrescentar - 
Digite 0 caso não deseje."); 
scanf("%d",&qt2); 
 if (qt2>0){ 
 v = (float*) realloc(v, (qtde+qt2)*sizeof(float)); 
 
 
 
 
36 Programação Estruturada 
AUMENTANDO O ESPAÇO ALOCADO 
 if (v){ 
 for (i=qtde;i<(qtde+qt2);i++){ 
 printf("Informe a nota: "); 
 scanf("%f", &v[i]); 
 soma=soma+v[i]; 
 } 
 media = soma / (qtde+qt2); 
 printf("Nova média: %.1f\n", media); 
 } 
 } 
} 
 
 
 
 
37 Programação Estruturada 
Exemplo – Alocação Dinâmica 
#include <stdio.h> 
struct ST_DADOS 
{ 
 char nome[40]; 
 float salario; 
 /* estrutura dentro de uma estrutura */ 
 struct nascimento 
 { 
 int ano; 
 int mes; 
 int dia; 
 } dt_nascimento; 
}; 
 
 
 
 
 
38 Programação Estruturada 
Exemplos 
int main(void){ 
 struct ST_DADOS * p; 
 p = (struct ST_DADOS *) malloc(sizeof(struct ST_DADOS)); 
 if (p){ 
 printf("\nEntre com o nome ->"); 
 scanf("%s", p->nome); 
 printf("Entre com o salario ->"); 
 scanf("%f", &p->salario); 
 printf("Entre com o nascimento ->"); 
 scanf("%d%d%d", &p->dt_nascimento.dia,&p-> 
dt_nascimento.mes, &p->dt_nascimento.ano); 
} 
 
 
 
 
39 Programação Estruturada 
Exemplos 
 printf("\n===== Dados digitados ===="); 
 printf("\nNome = %s", p->nome); 
 printf("\nSalario = %f", p->salario); 
 printf("\nNascimento = %d/%d/%d\n", 
p->dt_nascimento.dia,p->dt_nascimento.mes, 
p->dt_nascimento.ano); 
 free(p); 
} 
 
 
 
 
40 Programação Estruturada 
Alocação Dinâmica 
Através desse modo de alocação dinâmica, 
conseguimos alocar espaços de memória em tempo de 
execução e modificar o espaço alocado, também em 
tempo de execução. 
 
No entanto, todo o espaço alocado dinamicamente 
reservou um bloco de memória com endereços 
sequenciais, que foram manipulados como vetores. 
 
 
 
 
 
 
41 Programação Estruturada 
 
 
 
DÚVIDAS ? 
42 Programação Estruturada