Ponteiros void

Ponteiros void, também chamados de ponteiros genéricos, são um dos recursos mais flexíveis da linguagem C. Eles guardam o endereço de qualquer tipo de dado, o que permite escrever funções e estruturas de dados que funcionam para qualquer tipo.

O que é um ponteiro void?

Um ponteiro void * pode apontar para qualquer tipo de dado. Diferente dos ponteiros tipados (int *, char *, float *), ele não tem um tipo associado: guarda só o endereço.

void *ponteiro;

O mesmo ponteiro pode receber endereços de tipos diferentes:

int x = 10;
float y = 3.14;
char c = 'A';

void *ponteiro;

ponteiro = &x;   /* aponta para um int */
ponteiro = &y;   /* aponta para um float */
ponteiro = &c;   /* aponta para um char */

Não pode ser desreferenciado diretamente

Como o compilador não sabe o tipo do dado apontado, ele não sabe quantos bytes ler nem como interpretá-los. Por isso, um void * não pode ser desreferenciado sem antes ser convertido (cast) para um ponteiro tipado.

Experimente: o programa abaixo não compila. Corrija a linha 7 trocando *ponteiro por *(int *)ponteiro.

O mesmo ponteiro pode ser lido como tipos diferentes, desde que cada conversão corresponda ao tipo do dado que está naquele endereço:

Não permite aritmética de ponteiros

A aritmética de ponteiros depende do tamanho do tipo apontado: p + 1 avança sizeof(*p) bytes. Como void não tem tamanho, void * não admite aritmética:

int vetor[] = {1, 2, 3};
void *ponteiro = vetor;

/* ponteiro++;                      ERRO: void não tem tamanho */
ponteiro = (int *)ponteiro + 1;     /* CORRETO: avança sizeof(int) bytes */

void *ponteiro = vetor;

/* int x = ponteiro[1];             ERRO no C padrão */
int x = ((int *)ponteiro)[1];       /* CORRETO */

Quando precisar andar byte a byte por um bloco genérico, converta para char * (um char ocupa exatamente 1 byte): o elemento i de um vetor cujos elementos têm tamanho bytes começa em (char *)v + i * tamanho.

Casos de uso

Funções genéricas

A função abaixo troca dois valores de qualquer tipo, copiando os bytes com memcpy. Quem chama informa o tamanho de cada valor:

Alocação dinâmica

As funções malloc, calloc e realloc devolvem void *, justamente para servir a qualquer tipo. Em C, a conversão de void * para outro ponteiro é automática, então o cast é desnecessário:

int *v = malloc(5 * sizeof(int));          /* não precisa de (int *) */

Veja Alocação de Memória.

Estruturas de dados genéricas

Uma lista encadeada cujos nós guardam um void * pode armazenar dados de qualquer tipo. Abaixo, a mesma estrutura guarda inteiros numa lista e strings em outra:

Ordenação genérica com qsort

A função qsort, da biblioteca padrão, ordena vetores de qualquer tipo. Ela recebe o vetor como void *, o número de elementos, o tamanho de cada um e uma função de comparação, que recebe dois const void * e devolve um valor negativo, zero ou positivo:

void qsort(void *base, size_t n, size_t tamanho,
           int (*comparar)(const void *, const void *));

int comparar(const void *a, const void *b) {
    const Aluno *x = a;
    const Aluno *y = b;

    if (x->nota > y->nota) return -1;   /* maior nota vem antes */
    if (x->nota < y->nota) return 1;
    return strcmp(x->nome, y->nome);
}

Cuidados

Converta para o tipo certo

O compilador não verifica se o cast corresponde ao tipo do dado. Uma conversão errada não gera erro nem aviso: o programa apenas interpreta os bytes de forma equivocada.

Saiba qual é o tipo

Uma função que recebe só um void * não tem como descobrir o tipo do dado:

void funcaoGenerica(void *dado) {
    /* int, float ou struct? Não há como saber. */
}

Por isso, funções genéricas recebem informação extra: o tamanho do elemento (como trocar e qsort), uma função que sabe lidar com o tipo (como a comparação do qsort) ou um parâmetro que indica o tipo (por exemplo, um enum). Documente o que a função espera:

/**
 * Processa um vetor de elementos.
 * @param dados   vetor de int (int *)
 * @param tamanho número de elementos
 */
void processarVetor(void *dados, size_t tamanho);

Alinhamento

Cada tipo exige que seus valores fiquem em endereços múltiplos de um certo número (o alinhamento): um int, em geral, em múltiplos de 4. A memória devolvida por malloc é alinhada para qualquer tipo, mas um endereço obtido avançando byte a byte pode não ser:

Não devolva endereços de variáveis locais

void *obterDado(void) {
    int x = 42;    /* variável local */
    return &x;     /* ERRO: x deixa de existir quando a função termina */
}

Resumo das regras

Exercícios

1. O que o trecho imprime?

int v[] = {10, 20, 30, 40};
void *p = v;
printf("%d\n", *((int *)p + 2));
printf("%d\n", *(int *)((char *)p + 4));

2. Por que memcpy recebe void * e um tamanho em bytes?

3. Implemente. Escreva inverte, que inverte a ordem dos elementos de um vetor de qualquer tipo. Os testes usam vetores de int, double, char e de struct.