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

 

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