Pourquoi mon opérateur sizeof maison a-t-il besoin d'un cast char* ?

Question

Voici le programme permettant de trouver la taille d'une structure sans utiliser l'opérateur sizeof :

struct MyStruct
{
  int i;
  int j;
};

int main()
{
   struct MyStruct *p=0;
   int size = ((char*)(p+1))-((char*)p);
   printf("\nSIZE : [%d]\nSIZE : [%d]\n", size);
   return 0;
}

Pourquoi la conversion en char * est-elle nécessaire ?

Si je n'utilise pas le pointeur char*, la sortie est de 1 - pourquoi ?

Answer 1

Parce que l'arithmétique des pointeurs fonctionne en unités du type pointé. Par exemple :

int* p_num = malloc(10 * sizeof(int)); 
int* p_num2 = p_num + 5;

Ici, p_num2 n'a pas de point cinq octets au-delà de p_num il indique cinq nombres entiers au-delà de p_num . Si, sur votre machine, un entier a une largeur de quatre octets, l'adresse stockée dans le fichier p_num2 sera de vingt octets de plus que celui stocké dans p_num . La raison en est principalement que les pointeurs peuvent être indexés comme des tableaux. p_num[5] est exactement équivalent à *(p_num + 5) Il ne serait donc pas logique que l'arithmétique des pointeurs fonctionne toujours en octets, sinon p_num[5] vous donnerait des données qui commencent au milieu du deuxième entier, plutôt que de vous donner le sixième entier comme vous vous y attendiez.

Afin de déplacer un nombre spécifique de octets au-delà d'un pointeur, vous devez faire en sorte que le pointeur pointe vers un type dont la largeur est garantie à exactement 1 octet (un char ).

De plus, vous avez une erreur ici :

printf("\nSIZE : [%d]\nSIZE : [%d]\n", size);

Vous avez deux spécificateurs de format mais un seul argument après la chaîne de format.

Answer 2

Parce que vous voulez la taille de votre structure en octets. Et l'arithmétique des pointeurs utilise implicitement les tailles des types.

int* p;
p + 5; // this is implicitly p + 5 * sizeof(int)

En coulant vers char*, vous contournez ce comportement.

Answer 3

L'arithmétique des pointeurs est définie en fonction de la taille du type du pointeur. C'est ce qui permet (par exemple) l'équivalence entre l'arithmétique des pointeurs et l'inscription dans les tableaux -- *(ptr+n) est équivalent à ptr[n] . Lorsque vous soustrayez deux pointeurs, vous obtenez la différence sous la forme du nombre d'éléments sur lesquels ils pointent. Le jet vers pointer to char signifie qu'il vous indique le nombre de caractères entre ces adresses. Puisque le C fait char y byte essentiellement équivalent (c'est-à-dire qu'un octet est le stockage nécessaire pour un caractère) qui est aussi le nombre d'octets occupés par le premier élément.