Gerenciamento de Memória
Até agora não vimos gerenciamento manual de memória, apenas automático. Todas
variáveis auto que criamos são destruídas automaticamente quando saem do
escopo onde foram declaradas. A duração estática de armazenamento evita essa
destruição, porém o objeto estático é compartilhado entre todas chamadas da
função e persiste durante toda a execução programa. Para ter controle total da
duração de um objeto na memória, é necessário utilizar as funções de
gerenciamento de memória malloc e free, de <stdlib.h>.
Função malloc
A função malloc recebe a quantidade de bytes a serem alocados e retorna um
ponteiro que se refere à memória alocada. Isso significa que para alocar e
utilizar um int, basta fazer int *p = malloc(sizeof *p); ou
int *p = malloc(sizeof(int));. Todas as indireções no ponteiro acessarão o
objeto alocado.
int *AlocarInt(void)
{
return malloc(sizeof(int));
}
int main(void)
{
int *a = AlocarInt(),
*b = AlocarInt(),
*c = AlocarInt();
*a = 1;
*b = 2;
*c = 3;
// Exibe "1, 2, 3"
printf("%d, %d, %d\n",
*a, *b, *c);
return 0;
}Funções em C não podem retornar arrays mas podem retornar ponteiros. Assim, uma
forma de simular o retorno de array é alocar um array com malloc e retornar um
ponteiro para ele. Como exemplo, vejamos uma função abaixo.
// Retorna um array de qtd ints com valor val
int *FabricarArray(size_t qtd, int val)
{
int *array = malloc(sizeof(int[qtd]));
for (size_t i = 0; i < qtd; i = i + 1)
array[i] = val;
return array;
}
int main(void)
{
int *array = FabricarArray(9, 5);
// Exibirá "5 5 5 5 5 5 5 5 5 "
for (size_t i = 0; i < 9; i = i + 1)
printf("%d ", array[i]);
return 0;
}Lembre-se que embora um ponteiro suporte o operador [] e simule um array, ele
não é exatamente um array. O operador sizeof na variável array do código
acima não resulta no tamanho do array retornado pela função e sim no tamanho do
ponteiro.
int array[100];
int *ponteiro = FabricarArray(100, 0);
printf("sizeof array: %zu\nsizeof ponteiro: %zu\n",
sizeof array, sizeof ponteiro);Em um sistema específico, a execução do código acima exibiu sizeof array: 400
e sizeof ponteiro: 8, embora ambos possam acessar 100 ints com o operador
[].
Função free
Toda a memória alocada por malloc continua alocada até ser manualmente
liberada. Isso é feito aplicando a função free ao ponteiro que foi retornado
por malloc. O ponteiro retornado pela nossa função FabricarArray é alocado
por malloc, portanto esse procedimento deve ser feito.
int main(void)
{
int *array = FabricarArray(9, 5);
/* Utilizar o array ... */
free(array);
return 0;
}Após o free, acessar o ponteiro com * resulta em comportamento indefinido
até que um novo alvo válido seja dado a ele.
Referências
- ISO/IEC JTC1/SC22/WG14 N2310:
- 7.22.3.3 The free function