Aritmética de ponteiro para ponteiro vazio em C

Quando um ponteiro para um tipo específico (por exemplo int, char, float, ..) é incrementado, o seu valor é aumentado pelo tamanho de que tipo de dados. Se um voidponteiro que aponta para dados de tamanho xé incrementado, como ele aponta os xbytes à frente? Como o compilador sabe agregar xvalor ao ponteiro?

Conclusão final: aritmética em a void*é ilegal em C e C ++.

O GCC permite isso como uma extensão, consulte Aritmética sobre void- e Ponteiros de função (observe que esta seção faz parte do capítulo "Extensões C" do manual)). Clang e ICC provavelmente permitem void*aritmética para fins de compatibilidade com o GCC. Outros compiladores (como o MSVC) desabilitam a aritmética void*e o GCC o desabilita se o -pedantic-errorssinalizador for especificado ou se o -Werror-pointer-arithsinalizador for especificado (esse sinalizador é útil se sua base de código também precisar compilar com o MSVC).

O padrão C fala

As cotações são retiradas do rascunho n1256.

A descrição da norma da operação de adição indica:

6.5.6-2: Para adição, ambos os operandos devem ter um tipo aritmético ou um operando deve ser um ponteiro para um tipo de objeto e o outro deve ter um tipo inteiro.

Portanto, a questão aqui é se void*é um ponteiro para um "tipo de objeto" ou, equivalentemente, se voidé um "tipo de objeto". A definição para "tipo de objeto" é:

6.2.5.1: Os tipos são particionados em tipos de objetos (tipos que descrevem completamente objetos), tipos de funções (tipos que descrevem funções) e tipos incompletos (tipos que descrevem objetos, mas não possuem informações necessárias para determinar seus tamanhos).

E o padrão define voidcomo:

6.2.5-19: O voidtipo compreende um conjunto de valores vazio; é um tipo incompleto que não pode ser concluído.

Como voidé um tipo incompleto, não é um tipo de objeto. Portanto, não é um operando válido para uma operação de adição.

Portanto, você não pode executar aritmética de ponteiro em um voidponteiro.

Notas

Originalmente, pensava-se que a void*aritmética era permitida, devido a essas seções do padrão C:

6.2.5-27: Um ponteiro para anular deve ter os mesmos requisitos de representação e alinhamento que um ponteiro para um tipo de caractere.

Contudo,

Os mesmos requisitos de representação e alinhamento devem implicar intercambiabilidade como argumentos para funções, retornar valores de funções e membros de sindicatos.

Portanto, isso significa que printf("%s", x)tem o mesmo significado, seja xtype char*ou void*, mas não significa que você possa fazer aritmética em a void*.

Nota do editor: Esta resposta foi editada para refletir a conclusão final.

Aritmética de ponteiro não é permitida em void*ponteiros.

converta-o em um ponteiro de char e aumente seu ponteiro para a frente x bytes à frente.

O padrão C não permite aritmética de ponteiro nulo . No entanto, GNU C é permitido pelo considerando o tamanho do vazio é 1.

Norma C11 §6.2.5

Nº 19

O voidtipo compreende um conjunto vazio de valores; é um tipo de objeto incompleto que não pode ser concluído.

O programa a seguir está funcionando bem no compilador GCC.

#include<stdio.h>

int main()
{
    int arr[2] = {1, 2};
    void *ptr = &arr;
    ptr = ptr + sizeof(int);
    printf("%d\n", *(int *)ptr);
    return 0;
}

Outros compiladores podem gerar um erro.

Você não pode fazer aritmética de ponteiro nos void *tipos, exatamente por esse motivo!

Você deve convertê-lo em outro tipo de ponteiro antes de fazer a aritmética do ponteiro.

Ponteiros nulos podem apontar para qualquer pedaço de memória. Portanto, o compilador não sabe quantos bytes aumentar / diminuir quando tentamos aritmética de ponteiro em um ponteiro nulo. Portanto, os ponteiros nulos devem primeiro ser convertidos para um tipo conhecido antes que possam ser envolvidos em qualquer aritmética de ponteiro.

void *p = malloc(sizeof(char)*10);
p++; //compiler does how many where to pint the pointer after this increment operation

char * c = (char *)p;
c++;  // compiler will increment the c by 1, since size of char is 1 byte.

O compilador sabe por tipo de conversão. Dado um void *x:

• x+1 adiciona um byte a x , o ponteiro vai ao bytex+1
• (int*)x+1adiciona sizeof(int)bytes, o ponteiro vai para o bytex + sizeof(int)
• (float*)x+1sizeof(float)bytes de endereço , etc.

Embora o primeiro item não seja portátil e seja contra o Galateo do C / C ++, ele é correto na linguagem C, o que significa que ele será compilado com algo na maioria dos compiladores que talvez exijam uma sinalização apropriada (como -Wpointer-arith)