Diferença entre malloc() e calloc()

Principais diferenças entre malloc() e calloc()

• A função malloc() retorna apenas o endereço inicial e não o torna zero, por outro lado, a função calloc() retorna o endereço inicial e o torna zero.
• Na função malloc, o número de argumentos é 1, enquanto na função calloc, o número de argumentos é 2.
• A eficiência de tempo de malloc() é maior que calloc(), enquanto malloc() não é seguro em comparação com calloc()
• malloc não inicializa a memória, enquanto calloc executa a inicialização da memória.

O que é alocação dinâmica de memória?

Alocação dinâmica de memória é um processo de alocação de memória em tempo de execução. Existem quatro rotinas de biblioteca, calloc(), free(), realloc ()e malloc() que pode ser usado para alocar memória e liberá-la durante a execução do programa. Essas rotinas são definidas no arquivo de cabeçalho denominado stdlib.h.

O que é malloc()?

É uma função usada para alocar um bloco de memória dinamicamente. Ele reserva espaço de memória de tamanho especificado e retorna o ponteiro nulo apontando para o local da memória.

O ponteiro retornado geralmente é do tipo void. Isso significa que podemos atribuir a função malloc a qualquer ponteiro. A forma completa de malloc é a alocação de memória.

O que é calloc()?

Função Calloc() é usado para alocar vários blocos de memória. É uma função de alocação dinâmica de memória que é usada para alocar memória para estruturas de dados complexas, como arrays e estruturas. Se esta função não conseguir alocar espaço suficiente conforme especificado, ela retornará um ponteiro nulo. A forma completa da função calloc é a alocação contígua.

Diferença entre malloc() e calloc()

Aqui estão diferenças importantes entre malloc() e calloc():

Sintaxe de malloc()

Aqui está uma sintaxe de malloc()

ptr = (cast_type *) malloc (byte_size);

Na sintaxe acima, ptr é um ponteiro para cast_type. A função malloc retorna um ponteiro para a memória alocada de byte_size.

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

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

Sintaxe de calloc()

Aqui está uma sintaxe de malloc()

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

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

Exemplo de malloc() em C

No código abaixo, sizeof(*ptr) é usado para alocar um bloco de memória de 15 inteiros. Na instrução printf, encontramos o valor do 6º inteiro.

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

Saída:

O valor do 6º número inteiro é 480

Exemplo de calloc() em C

O programa em linguagem C abaixo calcula a soma dos primeiros dez termos. Se o valor do ponteiro for nulo, o espaço de memória não será alocado.

O loop For é usado para iterar o valor de uma variável “i” e imprimir a soma. Por último, a função free é usada para liberar o ponteiro.

#include <stdio.h>
#include <stdlib.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;
    }

Saída:

Construindo e calculando a soma sequencial dos primeiros 10 termos n Soma = 45

Por que usar malloc()?

Aqui estão as razões para usar malloc()

• Você deve usar malloc() quando precisar alocar memória em tempo de execução.
• Você deve usar malloc quando precisar alocar objetos que devem existir além da execução do bloco de memória atual.
• Vá para malloc() se precisar alocar memória maior que o tamanho dessa pilha.
• Ele retorna o ponteiro para o primeiro byte do espaço alocado.
• Ele permite que os desenvolvedores aloquem memória conforme necessário e na quantidade exata.
• Esta função aloca um tamanho de bloco de memória de bytes do heap.

Por que usar calloc()?

Aqui estão as razões para usar calloc()

• Quando você precisa definir a memória alocada como zero.
• Você pode usar calloc que retorna um ponteiro para obter acesso ao heap de memória.
• Usado quando você precisa inicializar os elementos em zero para retornar um ponteiro para a memória.
• Para evitar overflow que é possível com malloc()
• Use calloc() para solicitar uma página que já está zerada.