malloc free

Prévia do material em texto

malloc/free 
Quando se executa a função malloc (=memory allocation), o sistema operacional reserva um espaço de 
memória contiguo e exclusivo para o programa em execução. A função malloc retorna um ponteiro 
(endereço de memória) para o começo deste espaço de memória. Para usar a função malloc é 
necessário saber quantos bytes se quer reservar e onde guardar o ponteiro para o começo da 
memória reservada. Depois de usar o ponteiro deve-se usar a função free para liberar o espaço para 
futuro uso. 
Exemplo 1. 
#include <stdlib.h> 
main() 
{ 
 int *ptr; 
 ptr = (int *)malloc(5*sizeof(int)); 
 // uso do ponteiro ptr 
 free(ptr); 
} 
No exemplo acima, reserva-se um espaço de memória de 5*sizeof(int) bytes e o ponteiro para o 
começo deste espaço de memória fica guardado na variável ptr. Depois da invocação da função 
malloc e antes do free, a memória pode desenhar-se assim: 
 
Para acessar a memória apontada por ptr pode-se usar duas formas equivalentes: 
ptr[i] ou *(ptr+i) 
onde i pode variar entre 0 e 4. 
 
ptr[4] 
ptr[3] 
ptr[2] 
ptr[1] 
ptr[0] 
ptr 
Exemplo 2. 
#include <stdlib.h> 
main() 
{ 
 struct pessoa { 
 int rg; 
 char sexo; 
 float altura; 
 }; 
 struct pessoa *ptr; 
 ptr = (struct pessoa *)malloc(sizeof(struct pessoa)); 
 // uso do ponteiro ptr 
 free(ptr); 
} 
No exemplo acima, reserva-se um espaço de memória de sizeof(struct pessoa) bytes e o ponteiro 
para o começo deste espaço de memória fica guardado na variável ptr. Depois da invocação da 
função malloc e antes do free, a memória pode desenhar-se assim: 
 
O ponteiro ptr aponta para um struct com três partes: rg, sexo e altura. Para acessar a cada parte 
por meio de ptr pode-se usar duas formas equivalentes: 
 ptr->rg ou (*ptr).rg 
 ptr->sexo ou (*ptr).sexo 
 ptr->altura ou (*ptr).altura 
 
 
rg 
ptr 
sexo 
altura 
A função malloc pode dar errado... 
Quando pedimos memória com malloc pode acontecer que o sistema operacional não disponha de 
memória livre suficiente. Neste caso malloc retorna a constante NULL. Esta constante NULL significa 
“não foi possível reservar memória” ou “ponteiro para nenhum lugar”. Portanto, é importante 
sempre perguntar, depois de invocar a função malloc, se ele retornou NULL. Caso malloc retorne 
NULL podemos, por exemplo, enviar uma mensagem para o usuário e terminar. 
Exemplo 3. 
#include <stdlib.h> 
#include <stdio.h> 
main() 
{ 
 float *ptr; 
 ptr = (float *)malloc(999999999*sizeof(float)); // 999999999*sizeof(float) bytes é muito!! 
 if (ptr==NULL) { 
 printf(“malloc retorna NULL.\n”); 
 return; 
 } 
 // posso usar ptr aqui, pois se ptr==NULL o programa teria terminado no return 
 free(ptr); 
} 
 
Recomendações: 
 Se invocarmos malloc em algum momento do programa devemos nos preocupar em fazer o 
free para liberar o espaço reservado. [Se não fazemos o free, o sistema operacional pode 
ficar sem memória e o computador poderá ficar lento/instável. Reiniciar o computador pode 
ser uma solução para liberar a memória.] 
 Fazer um “if (ptr==NULL) {printf(“erro!\n”); return;}” na linha seguinte a invocação do 
malloc. Se ptr==NULL e fizermos “*ptr” ou “ptr->algo” o programa pode terminar sem dar 
mensagem de erro. Isso pode dificultar a busca de erros em nossos programas.