Função malloc() na biblioteca C com EXEMPLO

O que é malloc em C?

A função malloc() significa alocação de memória. É 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.

Sintaxe

ptr = (cast_type *) malloc (byte_size);

Aqui,

• ptr é um ponteiro de 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.

Considere outro exemplo de implementação de malloc:

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

Saída:

Value of the 6th integer is 480

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.

A alocação poderá falhar se a memória não for suficiente. Neste caso, ele retorna um ponteiro NULL. Portanto, você deve incluir código para verificar um ponteiro NULL.

Lembre-se de que a memória alocada é contígua e pode ser tratada como uma matriz. Podemos usar apontador Para acessar os elementos da matriz, utilize aritmética em vez de colchetes [ ]. Recomendamos o uso de + para se referir aos elementos da matriz, pois o uso de incrementos ++ ou += altera o endereço armazenado pelo ponteiro.

A função Malloc também pode ser usada com o tipo de dados de caractere, bem como com tipos de dados complexos, como estruturas.

Por que usar malloc() em C?

Arrays estáticos e variáveis ​​comuns têm seu tamanho fixo quando o programa é compilado, o que desperdiça espaço quando a necessidade de memória é menor e causa falhas quando a necessidade é maior. A função `malloc()` resolve isso solicitando memória em tempo de execução, permitindo que o programa dimensione um buffer exatamente de acordo com a quantidade de dados recebida. Essa flexibilidade em tempo de execução é a essência do programa. alocação de memória dinâmica em C.

A alocação dinâmica com malloc() é a escolha certa em diversas situações comuns:

• A quantidade de dados de entrada é desconhecida até que o programa seja executado, como, por exemplo, a leitura de um arquivo ou de uma lista fornecida pelo usuário.
• São necessários blocos grandes que causariam estouro da pilha limitada, já que malloc() utiliza a memória heap, que é muito maior.
• Os dados devem sobreviver à função que os criou, pois a memória heap persiste até ser explicitamente liberada.
• Estruturas e matrizes precisam crescer ou diminuir de tamanho durante a execução do programa.

Como o bloco reservado é retornado como um ponteiro, ele pode ser passado entre funções de forma eficiente, sem a necessidade de copiar os dados subjacentes.

Como liberar a memória alocada por malloc()

A memória reservada por malloc() reside no heap e nunca é liberada automaticamente. Quando um programa continua alocando memória sem liberá-la, ele consome lentamente toda a memória disponível, um defeito conhecido como vazamento de memória. A função free() retorna um bloco de memória finalizado para o sistema, permitindo que o espaço seja reutilizado.

A função free() recebe um único argumento, o ponteiro retornado por malloc(), e libera todo o bloco de memória de uma só vez:

int *ptr;
ptr = malloc(10 * sizeof(int));
if (ptr != NULL) {
    /* use the allocated memory here */
    free(ptr);   /* release the block */
    ptr = NULL;  /* avoid a dangling pointer */
}

Siga estas regras para gerenciar a memória dinâmica com segurança:

• Chame a função free() exatamente uma vez para cada alocação de bloco malloc() bem-sucedida; liberar o mesmo bloco duas vezes causa comportamento indefinido.
• Após liberar a memória, defina o ponteiro como NULL para que ele não possa ser reutilizado como um ponteiro pendente.
• Nunca use `free()` em um ponteiro que não foi retornado por `malloc()`, incluindo um ponteiro deslocado por aritmética de ponteiros.
• Para cada alocação, associe-a a uma liberação correspondente antes que o ponteiro saia do escopo.

Keeping A alocação e liberação balanceadas são a disciplina central do gerenciamento manual de memória em C, e previnem tanto vazamentos quanto travamentos causados ​​pela reutilização de memória liberada.

malloc() vs calloc(): Principais diferenças

malloc() e calloc () Ambas as funções reservam memória heap, mas diferem em seus argumentos e na forma como tratam o novo bloco. `malloc()` recebe um argumento, o número total de bytes, e deixa o conteúdo não inicializado, de modo que o bloco contém valores aleatórios imprevisíveis até que o programa escreva nele. `calloc()` recebe dois argumentos, o número de elementos e o tamanho de cada um, e limpa cada byte para zero antes de retornar o ponteiro.

As diferenças práticas se resumem a três pontos:

• Inicialização: calloc() zera a memória, enquanto malloc() não, o que torna malloc() ligeiramente mais rápido quando os valores serão sobrescritos de qualquer forma.
• Argumentos: você escreve malloc(n * size), mas calloc(n, size) para reservar o mesmo array.
• Caso de uso: escolha calloc() quando um bloco limpo e zerado for importante, e malloc() quando a velocidade for preferida e a inicialização for feita manualmente.

Ambas as funções são declaradas em stdlib.h, ambas retornam um ponteiro void ou NULL em caso de falha e ambas liberam a memória com a mesma função free().

Perguntas Frequentes