Alocação Dinâmica de Memória em C: malloc(), calloc() Funções

antes de aprender C Alocação Dinâmica de Memória, vamos compreender:

Como funciona a gestão da memória em C?

Quando declara uma variável utilizando um tipo de dados básicos, o compilador C atribui automaticamente espaço de memória para a variável num pool de memória chamado stack.

Por exemplo, uma variável flutuante leva normalmente 4 bytes (de acordo com a plataforma) quando é declarada. Podemos verificar esta informação utilizando o tamanho do operador, como mostrado no exemplo abaixo

#include <stdio.h>int main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}

A saída será:

 The size of float is 4 bytes 

Também, uma matriz com um tamanho especificado é atribuída em blocos contíguos de memória, cada bloco tem o tamanho para um elemento:

#include <stdio.h>int main() { float arr;printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;} 

O resultado é:

 The size of the float array with 10 element is 40

Como aprendido até agora, ao declarar um tipo de dados básicos ou um array, a memória é automaticamente gerida. Contudo, existe um processo de atribuição de memória em C que lhe permitirá implementar um programa em que o tamanho da matriz é indeciso até que execute o seu programa (tempo de execução). Este processo é chamado “alocação dinâmica de memória”.

Neste tutorial, irá aprender-

• Como funciona a Gestão da Memória em C?
• Alocação dinâmica de memória em C
• C malloc() Função
• A função livre() Função
• C calloc() Função
• calloc() vs. malloc(): Diferenças chaves
• C realloc() Função
• Arrays dinâmicos

Agora pode criar e destruir dinamicamente um conjunto de elementos em tempo de execução sem qualquer problema. Em resumo, a gestão automática da memória utiliza a pilha, e a Alocação Dinâmica de Memória C utiliza a pilha.

O <stdlib.h> biblioteca tem funções responsáveis pela Gestão Dinâmica da Memória.

realloc()

Função	Finalidade
malloc()	Atribui a memória do tamanho pedido e devolve o ponteiro ao primeiro byte do espaço atribuído.
calloc()	Atribui o espaço para elementos de uma matriz. Inicializa os elementos a zero e devolve um ponteiro à memória.
É utilizado para modificar o tamanho do espaço de memória previamente atribuído.
Free()	Free ou esvazia o espaço de memória previamente alocado.

Vamos discutir as funções acima com a sua aplicação

Sintaxe da função malloc():

ptr = (cast_type *) malloc (byte_size);

Here,

• ptr é um ponteiro do tipo cast_type.
• A função malloc() em C devolve um ponteiro à memória alocada de byte_size.

Exemplo de malloc():

Example: ptr = (int *) malloc (50)

Quando esta afirmação é executada com sucesso, é reservado um espaço de memória de 50 bytes. O endereço do primeiro byte do espaço reservado é atribuído ao ponteiro ptr do tipo int.

Considerar outro exemplo:

#include <stdlib.h>int main(){int *ptr;ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */ if (ptr != NULL) { *(ptr + 5) = 480; /* assign 480 to sixth integer */ printf("Value of the 6th integer is %d",*(ptr + 5)); }}

Output:

Value of the 6th integer is 480

1. Nota que foi utilizado o sizeof(*ptr) em vez do sizeof(int) a fim de tornar o código mais robusto quando a declaração *ptr for datilografada para um tipo de dados diferente mais tarde.
2. A atribuição pode falhar se a memória não for suficiente. Neste caso, devolve um ponteiro NULL. Portanto, deve incluir código para verificar se existe um ponteiro NULL.
3. Leve em mente que a memória alocada é contígua e pode ser tratada como uma matriz. Podemos usar aritmética de ponteiro para aceder aos elementos da matriz em vez de usar parênteses . Aconselhamos a utilização de + para se referir aos elementos da matriz porque a utilização de ++ ou += altera o endereço armazenado pelo ponteiro.

Função Malloc() também pode ser utilizada com o tipo de dados de caracteres, bem como com tipos de dados complexos, tais como estruturas.

A função free() Função

A memória para variáveis é automaticamente desalocada no momento da compilação. Na alocação dinâmica de memória, é necessário desalocar a memória explicitamente. Se não o fizer, pode encontrar um erro fora da memória.

A função free() é chamada para libertar/desalocar memória em C. Ao libertar a memória no seu programa, disponibilizará mais memória para utilização posterior.

Por exemplo:

#include <stdio.h>int main() {int* ptr = malloc(10 * sizeof(*ptr));if (ptr != NULL){ *(ptr + 2) = 50; printf("Value of the 2nd integer is %d",*(ptr + 2));}free(ptr);}

Eliminar

 Value of the 2nd integer is 50

C calloc() Função

A função C calloc() significa alocação contígua. Esta função é utilizada para alocar múltiplos blocos de memória. É uma função de alocação dinâmica de memória que é utilizada para alocar a memória a estruturas de dados complexas, tais como matrizes e estruturas.

Funçãoalloc() é utilizada para alocar um único bloco de espaço de memória enquanto que a função calloc() em C é utilizada para alocar múltiplos blocos de espaço de memória. Cada bloco atribuído pela função calloc() tem o mesmo tamanho.

Sintaxe da função calloc():

ptr = (cast_type *) calloc (n, size);

• A afirmação acima é utilizada para alocar n blocos de memória do mesmo tamanho.
• Após a atribuição do espaço de memória, todos os bytes são inicializados a zero.
• O ponteiro que se encontra actualmente no primeiro byte do espaço de memória atribuído é devolvido.

Quando existe um erro na alocação do espaço de memória, tal como a falta de memória, então um ponteiro nulo é devolvido.

Exemplo de calloc():

O programa abaixo calcula a soma de uma sequência aritmética.

#include <stdio.h> int main() { int i, * ptr, sum = 0; ptr = calloc(10, sizeof(int)); if (ptr == NULL) { printf("Error! memory not allocated."); exit(0); } printf("Building and calculating the sequence sum of the first 10 terms \ n "); for (i = 0; i < 10; ++i) { * (ptr + i) = i; sum += * (ptr + i); } printf("Sum = %d", sum); free(ptr); return 0; }

Resultado:

 Building and calculating the sequence sum of the first 10 termsSum = 45

calloc() vs. malloc(): Diferenças chave

Seguir é a diferença chave entre malloc() Vs calloc() em C:

A função calloc() é geralmente mais adequada e eficiente do que a função malloc(). Enquanto ambas as funções são utilizadas para atribuir espaço de memória, calloc() pode atribuir múltiplos blocos de uma só vez. Não é necessário solicitar um bloco de memória de cada vez. A função calloc() é utilizada em estruturas de dados complexas que requerem um maior espaço de memória.

O bloco de memória atribuído por um calloc() em C é sempre inicializado a zero enquanto que na função malloc() em C, contém sempre um valor de lixo.

Sintaxe da função realloc():

ptr = realloc (ptr,newsize);

A afirmação acima aloca um novo espaço de memória com um tamanho especificado no tamanho da variável newsize. Após a execução da função, o ponteiro será devolvido ao primeiro byte do bloco de memória. O novo tamanho pode ser maior ou menor do que a memória anterior. Não podemos ter a certeza de que se o bloco recentemente alocado apontar para o mesmo local que o bloco de memória anterior. Esta função irá copiar todos os dados anteriores na nova região. Garante que os dados permanecerão seguros.

Exemplo de reafectação():

#include <stdio.h>int main () { char *ptr; ptr = (char *) malloc(10); strcpy(ptr, "Programming"); printf(" %s, Address = %u\n", ptr, ptr); ptr = (char *) realloc(ptr, 20); //ptr is reallocated with new size strcat(ptr, " In 'C'"); printf(" %s, Address = %u\n", ptr, ptr); free(ptr); return 0;} 

Quando a realocação() em C resulta numa operação sem sucesso, devolve um ponteiro nulo, e os dados anteriores são também libertados.

#include <stdio.h> int main() { int * arr_dynamic = NULL; int elements = 2, i; arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocks for (i = 0; i < elements; i++) arr_dynamic = i; for (i = 0; i < elements; i++) printf("arr_dynamic=%d\n", i, arr_dynamic); elements = 4; arr_dynamic = realloc(arr_dynamic, elements * sizeof(int)); //reallocate 4 elements printf("After realloc\n"); for (i = 2; i < elements; i++) arr_dynamic = i; for (i = 0; i < elements; i++) printf("arr_dynamic=%d\n", i, arr_dynamic); free(arr_dynamic); } 

Resultado do programa Dynamic array em C no ecrã:

 arr_dynamic=0arr_dynamic=1After reallocarr_dynamic=0arr_dynamic=1arr_dynamic=2arr_dynamic=3

Sumário

• Podemos gerir dinamicamente a memória criando blocos de memória conforme necessário na pilha
• Em C Alocação Dinâmica de Memória, a memória é alocada em tempo de execução.
• Alocação dinâmica de memória permite manipular cadeias e matrizes cujo tamanho é flexível e pode ser alterado em qualquer altura no seu programa.
• É necessário quando não se tem ideia de quanta memória uma determinada estrutura vai ocupar.
• Malloc() em C é uma função dinâmica de alocação de memória que representa a alocação de blocos de memória com o tamanho específico inicializado a um valor de lixo
• Calloc() em C é uma função contígua de alocação de memória que aloca múltiplos blocos de memória de cada vez inicializada a 0
• Realoc() em C é utilizada para realocar a memória de acordo com o tamanho especificado.
• Free() é utilizada para limpar a memória alocada dinamicamente.