sizeof style: sizeof (type) ou sizeof variable?

J'ai vu deux styles d'utilisation sizeofpour les opérations liées à la mémoire (comme dans memsetou malloc):

• sizeof(type), et
• sizeof variable ou sizeof(variable)

Lequel préféreriez-vous, ou utiliseriez-vous un mélange des deux styles, et quand utiliseriez-vous chaque style? Quels sont les avantages et les inconvénients de chaque style et quand les utilisez-vous?

À titre d'exemple, je peux voir la paire de situations suivante où un style aide et l'autre non:

Lorsque vous obtenez l'indirection du pointeur incorrecte:

type *var;
...
memset(var, 0, sizeof var);    /* oops */

Lorsque le type change:

new_type var;    /* changed from old_type to new_type */
...
memset(&var, 0, sizeof(old_type));    /* oops */

Je perfer sizeof(variable)sur sizeof(type). Considérer:

int a1;
float a2;
memset(&a1,0,sizeof(a1));
memset(&a2,0,sizeof(a2));

contre.

int a1;
float a2;
memset(&a1,0,sizeof(int));
memset(&a2,0,sizeof(float));

Dans le premier cas, il est facile de vérifier que les bonnes tailles sont transmises memset. Dans le deuxième cas, vous devez constamment revoir les sections supérieure et inférieure pour vous assurer que vous êtes cohérent.

La préférence (comme toujours) est de refléter votre intention aussi directement que possible.

L'intention est-elle d'opérer contre la mémoire d'une variable existante? Si c'est le cas, alors utilisez sizeof(variable), car cela montre le plus fidèlement possible que c'est la mémoire de la variable elle-même qui vous intéresse.

L'intention est-elle d'effectuer un calcul sur le type, par exemple pour déterminer la quantité de mémoire à allouer pour une nouvelle instance? Si oui, utilisez sizeof(type).

Autrement dit, je préfère

struct foo *bar;
bar = (struct foo *) malloc(sizeof(struct foo));

plus de

bar = (struct foo *) malloc(sizeof(*bar));

comme ce dernier cas ressemble que vous essayez d'accéder à une variable qui n'existe pas, encore.

Par contre, je préfère

char Buffer[256];
memset(Buffer, 0, sizeof(Buffer));

plus de

char Buffer[256];
memset(Buffer, 0, 256 * sizeof(char));

comme l'intention est clairement de remplir à zéro le contenu de la variable, c'est donc la variable contre laquelle nous devons opérer. Essayer d'utiliser le type de métadonnées confond simplement les choses, ici.

Je préférerais largement sizeof(type)plus sizeof variable. Même si elle vous oblige à vous soucier plus sur le type et faire plus de changements, il vous aide à éviter les erreurs d'indirection de pointeur, qui se classent parmi les cause de bogues dans C .

Je ne m'inquiéterais pas autant des bugs dont le type sizeof(type)est changé; chaque fois que vous modifiez le type d'une variable, vous devez effectuer une analyse rapide pour voir où cette variable est utilisée et si vous devez modifier des sizeof(type)instructions. Même s'il y a toujours une chance de se tromper, cela présente un risque beaucoup plus faible que les erreurs d'indirection de pointeur.

Un avantage sizeof variableest pour les tableaux, mais dans la pratique, j'ai constaté que le passage de tableaux en paires de premier / len est beaucoup plus courant (dans ce cas, utilisez simplement la longueur), et il est également très facile de se tromper de taille en raison de désintégration tableau / pointeur, comme dans cet exemple:

ID_INLINE mat3_t::mat3_t( float src[ 3 ][ 3 ] ) {
  memcpy( mat, src, sizeof( src ) );    /* NOT the same as 3*3*sizeof(float) */
}

L'objectif est de supprimer la redondance. Si vous utilisez sizeof pour une opération liée à une variable, vous devez évidemment le refléter dans sizeof. Oui, vous pouvez gâcher comme dans le premier exemple, mais le remède n'est pas d'utiliser le type, mais * var, correspondant correctement au but.

Pour atténuer ces problèmes, il est habituel d'utiliser des macros, des modèles et des outils similaires formés pour le cas d'utilisation plutôt que sizeof nu.

Voir ma macro CLEAR qui est utilisée exclusivement au lieu d'un memset nu. J'ai sauvé mon cul plusieurs fois en cas de faute de frappe d'indirection ou lorsqu'un contenu de structure récupérait un vecteur ou une chaîne ...

La logique métier définit votre choix.

1. Si votre code fait référence à une variable particulière et sans cette variable, votre code n'a aucun sens - choisissez sizeof(var)

2. Si vous codez traite d'un ensemble de variables avec un type particulier - choisissez sizeof(type). Habituellement, vous en avez besoin si vous en avez un typedefqui définit de nombreuses variables que vous traitez différemment selon leur type (par exemple la sérialisation). Vous ne savez peut-être pas laquelle de ces variables restera dans les futures versions de code, donc choisir le type comme argument est logiquement correct. Même le changement de ces typedefparamètres n'affectera pas votre taille de ligne.

Selon la taille de l'objectif (variable) pourrait être la meilleure solution. De cette façon, vous pouvez modifier votre type de variable si nécessaire, sans corriger toutes les entrées pour le type. Mais encore une fois, cela dépend de votre objectif.