A função malloc - Como alocar memória na linguagem C

No tutorial passado de nossa apostila de C, vimos a importância da alocação dinâmica da memória, técnica contrária a que vínhamos fazendo, que era declarando tudo estaticamente.

Vamos agora ensinar como usar a função malloc(), uma das três funções (malloc, calloc e realloc) que o C possui para tratar a alocação de memória, além de vermos, finalmente, na prática, uma grande utilidade dos ponteiros em C.

É uma importante lição que será extensivamente usada em nossas lições sobre listas encadeadas, filas e pilhas.

• Baixe o conteúdo do site: Apostila de C

Quer se tornar um programador profissional?
Clique aqui e obtenha seu certificado.

Como usar a função malloc da stdlib.h

malloc(), de Memory Allocation, é uma função da biblioteca stdlib.h que recebe como argumento números inteiros positivos (size_t), que irão representar o número de bytes que iremos alocar.
Essa função retorna um ponteiro contendo o endereço do bloco alocado.
Sua sintaxe é:

void *malloc(size_t numero_de_bytes);

Aqui, notamos uma peculiaridade da função malloc() ( e da linguagem C).
A função retorna um ponteiro, mas ao contrário do que tínhamos visto anteriormente, ela não retorna um ponteiro de tipo específico (int, float, struct etc).

Como estudamos bem, os ponteiros precisam saber para que tipo de variável vão apontar, pois (dentre outras coisas), podemos fazer operações matemática com ponteiros.
Por exemplo: ptr++;

Se esse ponteiro apontar para um caractere, ao incrementarmos, ele pulará uma posição de endereço de memória.
Já se apontar para um inteiro, ele pulará sizeof(int) posições de endereço, para apontar para o próximo inteiro de um vetor, por exemplo.
Por isso é importante, e essencial, que o ponteiro saiba pra que tipo de dado ele aponta.

Como a função malloc() serve para declarar qualquer tipo de dado, seja int, float, double ou uma struct criada por você, sua sintaxe foi mostrada como void.
Ela retorna o endereço do bloco de memória que foi alocado. Ao passo que fazemos essa alocação, devemos fazer um cast, ou seja, fazer com que um ponteiro (de algum tipo já definido) receba essa endereço.
Se quisermos alocar um bloco de endereços para inteiros, ao invés do void* colocamos:

(int *) malloc(size_t bytes);

Lembrando que a função retorna um endereço de memória.
Logo, alguém (ponteiro) deve receber esse retorno.

Por exemplo, se quiséssemos alocar 20 caracteres para conter uma string, devemos fazer:

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    char *nome;
    nome = (char *) malloc(21);
 
    printf("Digite seu nome: ");
    gets(nome);
 
    printf("%sn", nome);
 
    return 0;
}

(Por que alocamos 21 caracteres, se queremos usar apenas 20?)
Poderíamos criar o ponteiro e logo na declaração fazer ele receber o endereço de um bloco alocado de memória:

char *nome = (char *) malloc(21);

Dica: usar sizeof()

Outra boa prática é evitar o uso de números para escolher o número de bytes alocados.
Isso se deve ao fato de diferentes variáveis terem diferentes valores, dependendo da arquitetura.
Há máquina que um inteiro ocupa 2 bytes, em outras ocupam 4 bytes.

Sim, é um processo trabalhoso e enfadonho. E isso não é o pior.
Como veremos no próximo tutorial de C de nossa apostila, vamos ver os principais problemas decorrentes de uma má alocação de memória.
É um assunto um pouco delicado, mas não devemos fugir do uso dinâmico de memória, pois essa é uma das técnicas mais úteis para se otimizar programas, deixá-los mais rápidos e fazer menos uso de memória.


Para alocar de maneira correta, sem medo de errar (e de ser feliz), use a função sizeof():

char *nome = (char *) malloc(21*sizeof(char));

Sim, é um processo trabalhoso e enfadonho. E isso não é o pior.
Como veremos no próximo tutorial de C de nossa apostila, vamos ver os principais problemas decorrentes de uma má alocação de memória.

Por hora, estamos mostrando apenas exemplos simples.
Obviamente que os computadores atuais tem muitos mais memória que 20 bytes para um nome, e em aplicativos simples como este, a alocação não é necessária.
Mas para trabalhar com microprocessadores e microcontroladores, por exemplo, onde o tamanho da memória é algo crítico, é necessário ter controle de cada byte.

Mas ainda nesse curso você verá uma utilização bem prática e essencial da alocação dinâmica de memória (e consequentemente, mais uma aplicação de ponteiros), que será no estudo de estruturas dinâmicas de dados, para fazer Listas encadeadas, Filas e Pilhas.

Por hora, vamos treinar os conceitos básicos.

Exercício: Calculando a média de qualquer quantidade de números com malloc()

Crie um programa que calcula a média de uma quantidade qualquer (informada pelo usuário) de números.
O programa deve armazenas esses números em um vetor. Depois, use esse vetor para mostrar todos os números e mostrar a média dele.
Use alocação dinâmica de memória para colocar os números no vetor. Não desperdice memória.

Resolveremos essa questão no próximo tutorial de nossa apostila de C, quando ensinarmos a desalocar (liberar) a memória alocada, com a função free().