Alocação dinâmica de memória (C/C++)

Alocação dinâmica de memória (C/C++)

 

Alocação de memória é uma técnica de “controle” de memória, utilizados em programas de maiores dimensões. É importante para que um programador tenha idéia do que se trata e como se utiliza alocação de memória, leia-se buffers para entrada e saída de dados.

Existem duas funções fornecidas pelas bibliotecas C para controle de memória alocada dinamicamente.
Podemos fazer alocação de memória de tamanho (size) em bytes e para liberar memória alocada com o malloc.

Alocação de memória:
void *malloca(size_t size)

Liberar memória:
void free(void *ptr)

O operador sizeof é útil para especificar o valor do argumento de malloc, ou seja, o tamanho a ser aloca em bytes. Exemplo:

ptr = malloc(n * sizeof(int));

Lembrando sempre, que a memória tem suas limitações, ou seja, não podemos alocar espaço na memória quando bem querermos ou quando quisermos! É importante, antes de usar o malloc, verificar se ele retorna um valor não nulo:

ptr = malloc(n * sizeof(int));
if(ptr = NULL){

printf(‘Espaço na memória’);
return 0;
}

Normalmente, quando você utiliza o recurso da memória alocada dinacamente, pode ocorrer dois tipos de erro:

Fugas de memória (memory leaks): Quando a memória não pode ser liberada quando ela não é mais necessária. Isto pode conduzir o encerramento de um programa automaticamente (sem nenhum aviso prévio).

Danling pointers: Acontece quando os ponteiros utilização blocos de memória já liberados. Isto provoca a famosa mensagem de erro: “Segmentation violation: core dumped.”

Um dos maiores problemas do C em relação a estes tipos de erro é a indentificação do mesmo. Para evitar estes tipos de erro, o programador deve ser cuidadoso e usar um padrão conveniente na hora utilizar os ponteiros e alocação de memória dinâmica em seu código.

Uma prática comum em alocação dinâmica de memória é alocação de buffers, que são utilizados para guardar dados a ler de dispositivos periféricos de entrada ou escrever me dispositivos periféricos de saída. Exemplo:

Para ler algum dado:
ssize_t read(int fd, void *buf, size_t count);

Para escrever algum dado:
ssize_t write(int fd, void *buf, size_t count)

Não se esqueça! Ambas funções deve conter um endereço buffer de memória!

Podemos usar duas alternativas na alocação de buffer de memória:

Alocação estática:
char buf[BUFSIZ];
[…]
n = read(fd, buf, BUFSIZ);

Alocação dinâmica:
char *buf;
[…]
if((buf = malloc(BUFSIZ)) = NULL){
printf(‘Fora da memória!\n’);
exit(1);
}
n = read(fd, buf, BUFSIZ);

Lembre-se! É de suma importância usar um apontador inicializado nestas funções, como a read() por exemplo.

É um resumo sobre alocação dinâmica de memória. Sempre tome cuidado na hora de programar!

Alan Machado

 

Anúncios

Deixe uma Resposta

Preencha os seus detalhes abaixo ou clique num ícone para iniciar sessão:

Logótipo da WordPress.com

Está a comentar usando a sua conta WordPress.com Terminar Sessão / Alterar )

Imagem do Twitter

Está a comentar usando a sua conta Twitter Terminar Sessão / Alterar )

Facebook photo

Está a comentar usando a sua conta Facebook Terminar Sessão / Alterar )

Google+ photo

Está a comentar usando a sua conta Google+ Terminar Sessão / Alterar )

Connecting to %s