Parte 3 - Alocação Dinâmica (PUC)

Prévia do material em texto

Prof. Edson J. R. Justino
Prof. Claudio Carvilhe
Parte 3
Pontifícia Universidade Católica do Paraná - PUCPR
ArrayArray DinâmicoDinâmico
�� Usando as funUsando as funçções padrões da ões padrões da 
biblioteca da linguagem C, seu biblioteca da linguagem C, seu 
programa pode alocar memprograma pode alocar memóória, ria, 
enquanto estenquanto estáá sendo executado sendo executado 
(Dinamicamente) e desta forma criar um (Dinamicamente) e desta forma criar um 
arrayarray dinâmicodinâmico..
Código Executável Dados de Inicialização Disponível
Memória
ArrayArray DinâmicoDinâmico
�� As funAs funçções para a alocaões para a alocaçção dinâmica de memão dinâmica de memóória, são as ria, são as 
seguintes:seguintes:
mallocmalloc( )( ) AlocaAlocaçção de memão de memóória;ria;
calloccalloc( )( ) AlocaAlocaçção de memão de memóória em blocos;ria em blocos;
reallocrealloc( )( ) RealocaRealocaçção de blocos de memão de blocos de memóória;ria;
freefree( )( ) LiberaLiberaçção de blocos de memão de blocos de memóória alocados.ria alocados.
�� Os tipos retornados por essas funOs tipos retornados por essas funçções estão declarados no ões estão declarados no 
arquivo de header arquivo de header malloc.hmalloc.h
ArrayArray DinâmicoDinâmico
�� A funA funçção ão mallocmalloc( )( )
�� Ela recebe um argumento simples, que Ela recebe um argumento simples, que 
contcontéém o nm o núúmero de bytes de memmero de bytes de memóória a ria a 
ser alocado, e retorna o endereser alocado, e retorna o endereçço do o do 
primeiro byte dessa primeiro byte dessa áárea. rea. 
�� Se a funSe a funçção ão mallocmalloc( ) não puder alocar a ( ) não puder alocar a 
áárea desejada, ela retorna um NULL.rea desejada, ela retorna um NULL.
ArrayArray DinâmicoDinâmico
#include <#include <stdio.hstdio.h>>
#include <#include <malloc.hmalloc.h>>
..
..
intint **iptriptr;;
unsigned unsigned intint byte = 100;byte = 100;
..
iptriptr = = malloc(bytesmalloc(bytes););
↑↑ nnúúmero de bytes desejadosmero de bytes desejados
..
if ( if ( iptriptr == NULL)== NULL)
/* erro*//* erro*/
ArrayArray DinâmicoDinâmico
�� A funA funçção ão freefree()()
�� A funA funçção ão freefree libera a memlibera a memóória alocada pela ria alocada pela 
funfunçção ão mallocmalloc ou ou calloccalloc))
freefree((iptriptr););
ArrayArray DinâmicoDinâmico
�� A funA funçção ão freefree()()
IMPORTANTE:IMPORTANTE:
TODO BLOCO DE MEMTODO BLOCO DE MEMÓÓRIA ALOCADO RIA ALOCADO 
DEVE SER LIBERADO NO FINAL!DEVE SER LIBERADO NO FINAL!
ArrayArray Dinâmico Dinâmico –– mallocmalloc()()
/*********************************************/*********************************************
Exemplo do uso da funExemplo do uso da funçção ão mallocmalloc( ), para ( ), para 
alocaalocaçção dinâmica de memão dinâmica de memóória(ria(arrayarray dinâmico)dinâmico)
*********************************************/*********************************************/
#include <#include <stdio.hstdio.h>>
#include <#include <string.hstring.h>>
#include <#include <malloc.hmalloc.h>>
#include <#include <process.hprocess.h>>
int int mainmain(){(){
charchar **strstr; ; /* ponteiro que receber/* ponteiro que receberáá o endereo endereçço do bloco de memo do bloco de memóória alocado */ria alocado */
strstr = (char *) = (char *) mallocmalloc (11); (11); /* Alocando mem/* Alocando memóória para uma string com 11 caracteres*/ria para uma string com 11 caracteres*/
if(strif(str == NULL) {== NULL) {
putsputs((““Não existe memNão existe memóória para o bufferria para o buffer””););
exitexit(1); (1); /* termina a execu/* termina a execuçção e retorna um cão e retorna um cóódigo de erro para o sistema operacional */digo de erro para o sistema operacional */
}}
strcpystrcpy((strstr,,””Vamos ver!Vamos ver!””);); /* copia /* copia ““Vamos ver!Vamos ver!””, para a , para a áárea de memrea de memóória alocada */ria alocada */
printfprintf((““A string A string éé %s%s\\nn””,str);,str); /* imprime a cadeia de caracteres *//* imprime a cadeia de caracteres */
freefree((strstr);); /* libera o bloco de mem/* libera o bloco de memóória */ria */
returnreturn(0);(0);
}}
ArrayArray Dinâmico Dinâmico –– mallocmalloc()()
�� A funA funçção ão mallocmalloc()()
�� Um recurso importante da linguagem C, Um recurso importante da linguagem C, 
consiste na alocaconsiste na alocaçção do bloco, informando o ão do bloco, informando o 
nnúúmero de bytes a partir da funmero de bytes a partir da funçção ão sizeofsizeof. . 
Exemplos:Exemplos:
..
a=(int *) a=(int *) mallocmalloc (2*(2*sizeofsizeof(int));(int));
..
b=(b=(charchar*) *) mallocmalloc (10*(10*sizeofsizeof((charchar));));
..
m=(m=(floatfloat*) *) mallocmalloc (3*3*(3*3*sizeofsizeof((floatfloat));));
Exercício
� Elabore um programa em C que efetua a alocação dinâmica de 
matrizes, com base na escolha do usuário (o usuário deve informar 
o número de LINHAS E COLUNAS). A partir disto, seu programa 
deve obter DUAS MATRIZES, informadas pelo usuário. E exibir 
como resultado:
� SOMA ENTRE AS MATRIZES;
� SUBTRAÇÃO ENTRE AS MATRIZES;
� MULTIPLICAÇÃO ENTRE A MATRIZ E UM ESCALAR;
� CÁLCULO DA DIAGONAL DAS MATRIZES (em separado).
Ponteiros e Estruturas
� Podemos utilizar ponteiros para variáveis dos tipos int,
char, etc. Como uma estrutura é do tipo de dado como os 
demais, é possível a utilização de apontadores para ela.
� ponteiro pt_data, é capaz de apontar para o primeiro byte 
de uma variável do tipo data, permitindo, então, que seus 
campos sejam acessados isoladamente.
Ex:
struct data *pt_data;
Ex:
pt_data->campo
Ponteiros e Estruturas
#include <stdio.h> 
struct movimento {
long numero;
double valor;
char codigo;
};
void novo_mov(struct movimento *);
int main( ){
struct movimento reg_mov;
novo_mov(&reg_mov);
printf("Numero: %d\n", reg_mov.numero);
printf("Valor: %f\n",reg_mov.valor); 
printf("Código: %c\n",reg_mov.codigo);
system("PAUSE");
return 0;
}
void novo_mov(struct movimento *pt_mov){
pt_mov->numero = 9999;
pt_mov->valor = 1000.00;
pt_mov->codigo = 'c';
}
O operador flecha é utilizado para acessar os 
campos, em ponteiros para estruturas.
ArrayArray Dinâmico e Dinâmico e 
EstruturasEstruturas
/*********************************************/*********************************************
Exemplo do uso da funExemplo do uso da funçção ão mallocmalloc( ), para aloca( ), para alocaçção dinâmica de memão dinâmica de memóória(ria(arrayarray dinâmico) e dinâmico) e 
estruturaestrutura
*********************************************/*********************************************/
#include <#include <stdio.hstdio.h>>
#include <#include <string.hstring.h>>
#include <#include <malloc.hmalloc.h>>
#include <#include <process.hprocess.h>>
structstruct regreg{{
char nome[40]; char nome[40]; 
char end[50]; char end[50]; 
intint idadeidade; ; 
float float salsal;;
};};
ArrayArray Dinâmico e Dinâmico e 
EstruturasEstruturas
intint main(){main(){
structstruct regreg **strstr;;
strstr = (= (structstruct regreg *) *) malloc(malloc(sizeof(structsizeof(struct regreg))) ;) ; /* Alocando mem/* Alocando memóória para um registro */ria para um registro */
if (if (strstr == NULL== NULL ) {) {
printfprintf("Não existe mem("Não existe memóória para ser alocadaria para ser alocada\\n");n");
exitexit(1);(1);
}}
/* copia dados para o registro *//* copia dados para o registro */
strcpystrcpy ((strstr-->nome,"João da Silva"); >nome,"João da Silva"); 
strcpystrcpy ((strstr-->end,"Rua Fran>end,"Rua Françça, 123");a, 123");
strstr-->idade = 34;>idade = 34;
strstr-->sal = (>sal = (floatfloat) 2000.00;) 2000.00;
/* imprime o registro *//* imprime o registro */
printfprintf ((““Nome: %Nome: %ss\\nEdereconEdereco:%: %ss\\nIdadenIdade: %: %dd\\nSalarionSalario: %5.2f",: %5.2f", strstr-->>nome,strnome,str-->>end,strend,str-->>idadeidade, , strstr-->>salsal););
freefree((strstr);); /* libera a mem/* libera a memóória *ria *//
returnreturn 0;0;
}}