Alocação dinâmica de memória em C usando funções malloc(), calloc()

função malloc() em C

ptr = (cast_type *) malloc (byte_size);

• ptr é um ponteiro de cast_type.
• A função C malloc() retorna um ponteiro para a memória alocada de byte_size.

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

#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));
    }
}

Value of the 6th integer is 480

1. Observe que sizeof(*ptr) foi usado em vez de sizeof(int) para tornar o código mais robusto quando a declaração *ptr for convertida para um tipo de dados diferente posteriormente.
2. A alocação pode falhar se a memória não for suficiente. Nesse caso, ele retorna um ponteiro NULL. Portanto, você deve incluir código para verificar se há um ponteiro NULL.
3. Lembre-se de que a memória alocada é contígua e pode ser tratada como um array. Podemos usar a aritmética de ponteiro para acessar os elementos da matriz em vez de usar colchetes [ ]. Aconselhamos usar + para se referir a elementos do array porque usar incrementação ++ ou +=altera o endereço armazenado pelo ponteiro.

função free() em C

#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);
}

 Value of the 2nd integer is 50

função calloc() em C

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

• A instrução acima é usada para alocar n blocos de memória do mesmo tamanho.
• Depois que o espaço de memória é alocado, todos os bytes são inicializados em zero.
• O ponteiro que está atualmente no primeiro byte do espaço de memória alocado é retornado.

#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;
    }

Building and calculating the sequence sum of the first 10 terms
Sum = 45

calloc() vs. malloc():principais diferenças

função realloc() em C

ptr = realloc (ptr,newsize);

#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;
}

Matrizes dinâmicas em C

#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] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        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] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        free(arr_dynamic);
    }

 
arr_dynamic[0]=0
arr_dynamic[1]=1
After realloc
arr_dynamic[0]=0
arr_dynamic[1]=1
arr_dynamic[2]=2
arr_dynamic[3]=3

Resumo

• Podemos gerenciar dinamicamente a memória criando blocos de memória conforme necessário no heap
• Na alocação de memória dinâmica C, a memória é alocada em tempo de execução.
• A alocação dinâmica de memória permite manipular strings e arrays cujo tamanho é flexível e pode ser alterado a qualquer momento em seu programa.
• É necessário quando você não tem ideia de quanta memória uma estrutura específica vai ocupar.
• Malloc() em C é uma função de alocação de memória dinâmica que significa alocação de memória que blocos de memória com o tamanho específico inicializado para um valor de lixo
• Calloc() em C é uma função de alocação de memória contígua que aloca vários blocos de memória em um momento inicializado em 0
• Realloc() em C é usado para realocar memória de acordo com o tamanho especificado.
• A função Free() é usada para limpar a memória alocada dinamicamente.