Arithmétique du pointeur pour le pointeur vide en C

Quand un pointeur vers un type particulier ( par exemple int, char, float, ..) est incrémentée, la valeur est augmentée de la taille de ce type de données. Si un voidpointeur qui pointe vers des données de taille xest incrémenté, comment parvient-il à pointer les xoctets en avant? Comment le compilateur sait-il ajouter xà la valeur du pointeur?

Conclusion finale: l'arithmétique sur a void*est illégale en C et C ++.

GCC l'autorise comme extension, voir Arithmétique sur void- et pointeurs de fonction (notez que cette section fait partie du chapitre "Extensions C" du manuel). Clang et ICC autorisent probablement l' void*arithmétique à des fins de compatibilité avec GCC. D'autres compilateurs (comme MSVC) interdisent l'arithmétique sur void*, et GCC l'interdit si l' -pedantic-errorsindicateur est spécifié, ou si l' -Werror-pointer-arithindicateur est spécifié (cet indicateur est utile si votre base de code doit également compiler avec MSVC).

La norme C parle

Les citations sont tirées du projet n1256.

La description standard de l'opération d'ajout indique:

6.5.6-2: Pour l'addition, soit les deux opérandes doivent être de type arithmétique, soit un opérande doit être un pointeur vers un type d'objet et l'autre doit être de type entier.

Donc, la question ici est de savoir si void*est un pointeur vers un "type d'objet", ou de manière équivalente, s'il voids'agit d'un "type d'objet". La définition du "type d'objet" est:

6.2.5.1: Les types sont divisés en types d'objets (types qui décrivent complètement les objets), types de fonction (types qui décrivent des fonctions) et types incomplets (types qui décrivent des objets mais manquent des informations nécessaires pour déterminer leurs tailles).

Et la norme définit voidcomme:

6.2.5-19: le voidtype comprend un ensemble vide de valeurs; c'est un type incomplet qui ne peut pas être complété.

Puisqu'il voids'agit d'un type incomplet, ce n'est pas un type d'objet. Ce n'est donc pas un opérande valide pour une opération d'addition.

Par conséquent, vous ne pouvez pas effectuer d'arithmétique de pointeur sur un voidpointeur.

Remarques

À l'origine, on pensait que l' void*arithmétique était autorisée, en raison de ces sections de la norme C:

6.2.5-27: Un pointeur vers void doit avoir les mêmes exigences de représentation et d'alignement qu'un pointeur vers un type de caractère.

cependant,

Les mêmes représentation et alignement des exigences sont censées impliquer interchangeabilité comme arguments à des fonctions, des valeurs de retour des fonctions et des membres des syndicats.

Cela signifie donc que cela printf("%s", x)a la même signification, qu'il xsoit de type char*ou void*, mais cela ne signifie pas que vous pouvez faire de l'arithmétique sur un void*.

Note de l'éditeur: Cette réponse a été modifiée pour refléter la conclusion finale.

L'arithmétique des pointeurs n'est pas autorisée sur les void*pointeurs.

transtypez-le en pointeur char et incrémentez votre pointeur en avant de x octets.

La norme C n'autorise pas l' arithmétique des pointeurs vides . Cependant, GNU C est autorisé en considérant la taille de void est 1.

Norme C11 §6.2.5

Paragraphe - 19

Le voidtype comprend un ensemble vide de valeurs; il s'agit d'un type d'objet incomplet qui ne peut pas être complété.

Le programme suivant fonctionne bien dans le compilateur 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;
}

Peut-être que d'autres compilateurs génèrent une erreur.

Vous ne pouvez pas faire d'arithmétique de pointeur sur les void *types, exactement pour cette raison!

Vous devez le convertir en un autre type de pointeur avant d'effectuer l'arithmétique du pointeur.

Les pointeurs vides peuvent pointer vers n'importe quel bloc de mémoire. Par conséquent, le compilateur ne sait pas combien d'octets incrémenter / décrémenter lorsque nous tentons d'arithmétique de pointeur sur un pointeur void. Par conséquent, les pointeurs vides doivent d'abord être transtypés vers un type connu avant de pouvoir être impliqués dans une arithmétique de pointeur.

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.

Le compilateur connaît par type cast. Étant donné un void *x:

• x+1ajoute un octet à x, le pointeur passe à l'octetx+1
• (int*)x+1ajoute des sizeof(int)octets, le pointeur passe à l'octetx + sizeof(int)
• (float*)x+1addres sizeof(float)octets, etc.

Bien que le premier élément ne soit pas portable et soit contre le Galateo de C / C ++, il est néanmoins correct en langage C, ce qui signifie qu'il se compilera en quelque chose sur la plupart des compilateurs nécessitant éventuellement un drapeau approprié (comme -Wpointer-arith)