Que signifie sizeof (int )?

Je suis nouveau dans le kernel Linux. Je lis le fichier ioctl.h , j’ai rencontré une macro _IOC_TYPECHECK(t) , qui ressemble à ceci:

 #define _IOC_TYPECHECK(t) \ ((sizeof(t) == sizeof(t[1]) && \ sizeof(t) < (1 << _IOC_SIZEBITS)) ? \ sizeof(t) : __invalid_size_argument_for_IOC) 

Pouvez-vous m’expliquer ce code? Dans ce code, que signifie sizeof(t[1]) ?

Ceci est utilisé pour vérifier la validité du troisième paramètre des _IOR / _IOW / _IOWR , qui est supposé être un type. Il vérifie que le paramètre est en fait un type (et non une variable ou un nombre) et provoque sinon une erreur du compilateur ou de l’éditeur de liens.

  • Si t est un type, alors t[1] est le type “un tableau de 1 t “. Ce type a la même taille que t , et donc sizeof(t) == sizeof(t[1]) est vrai.

  • Si t est un nombre, sizeof(t) ne sera pas compilé.

  • Si t est une variable simple (non-tableau), alors t[1] provoquera une erreur du compilateur.

  • Si t est une variable de tableau, sizeof(t) == sizeof(t[1]) sera faux et une erreur de l’éditeur de liens sera provoquée (car __invalid_size_argument_for_IOC n’est pas défini).

L’expression sizeof(t) < (1 << _IOC_SIZEBITS) vérifie que la taille du type t ne dépasse pas le maximum autorisé pour ioctl et entraîne sinon le même éditeur de liens.

Certains cas non valides ne seront pas interceptés par cette macro - par exemple, lorsque t est un pointeur sur un pointeur.

Cela signifie la même chose que toutes les autres utilisations de sizeof . Il calcule la taille de l’expression.

Dans ce cas particulier, je soupçonne que la vérification est destinée à garantir une propriété de t (qui devrait être un nom de type, pas une variable) que je ne connais pas dans le contexte … Peut-être est-il possible de le traiter comme un pointeur (nécessaire pour l’indexation du tableau) qui exclurait certains types. Le commentaire à côté de la macro dit /* provoke comstack error for invalid uses of size argument */ ce qui semble corroborer cette théorie.

Notez que sizeof est un opérateur, pas une fonction. Les parenthèses ne sont pas nécessaires, sauf lorsque vous souhaitez calculer directement la taille d’un type, puis font partie de l’expression (il s’agit d’une expression cast). Donc, cela pourrait être écrit sizeof t == sizeof t[1] && ... , ou peut-être (sizeof t == sizeof t[1]) pour plus de clarté.

C’est un très bon style à utiliser, car il “verrouille” la taille en cours de calcul sur le tableau approprié, au lieu de répéter le type de t . Donc, si le type devait changer, l’expression serait automatiquement adaptée et continuerait de calculer la bonne chose.

Beaucoup de programmeurs C semblent préférer avoir des parenthèses autour de l’argument argument pour sizeof dans tous les cas, pour une raison quelconque.