Comment puis-je utiliser «sizeof» dans une macro de préprocesseur?

Existe-t-il un moyen d'utiliser une sizeofmacro dans une macro de préprocesseur?

Par exemple, il y a eu une tonne de situations au fil des ans dans lesquelles je voulais faire quelque chose comme:

#if sizeof(someThing) != PAGE_SIZE
#error Data structure doesn't match page size
#endif

La chose exacte que je vérifie ici est complètement inventée - le fait est que j'aime souvent mettre ces types de vérifications au moment de la compilation (taille ou alignement) pour me prémunir contre quelqu'un qui modifie une structure de données qui pourrait désaligner ou ré-aligner dimensionner les choses qui les briseraient.

Inutile de dire que je ne semble pas être en mesure d'utiliser un sizeofde la manière décrite ci-dessus.

Il existe plusieurs façons de procéder. Les extraits de code suivants ne produiront aucun code s'ils sont sizeof(someThing)égaux PAGE_SIZE; sinon, ils produiront une erreur de compilation.

1. Voie C11

À partir de C11, vous pouvez utiliser static_assert(nécessite #include <assert.h>).

Usage:

static_assert(sizeof(someThing) == PAGE_SIZE, "Data structure doesn't match page size");

2. Macro personnalisée

Si vous souhaitez simplement obtenir une erreur de compilation alors que ce sizeof(something)n'est pas ce à quoi vous vous attendez, vous pouvez utiliser la macro suivante:

#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))

Usage:

BUILD_BUG_ON( sizeof(someThing) != PAGE_SIZE );

Cet article explique en détail pourquoi cela fonctionne.

3. Spécifique à MS

Sur le compilateur Microsoft C ++, vous pouvez utiliser la macro C_ASSERT (requiert #include <windows.h>), qui utilise une astuce similaire à celle décrite dans la section 2.

Usage:

C_ASSERT(sizeof(someThing) == PAGE_SIZE);

Est-il possible d'utiliser un " sizeof" dans une macro de pré-processeur?

Non. Les directives conditionnelles acceptent un ensemble restreint d'expressions conditionnelles; sizeofest l'une des choses interdites.

Les directives de prétraitement sont évaluées avant que la source ne soit analysée (du moins sur le plan conceptuel), il n'y a donc pas encore de types ou de variables pour obtenir leur taille.

Cependant, il existe des techniques pour obtenir des assertions au moment de la compilation en C (par exemple, voir cette page ).

Je sais que c'est une réponse tardive, mais pour ajouter à la version de Mike, voici une version que nous utilisons qui n'alloue aucune mémoire. Je n'ai pas trouvé le contrôle de taille d'origine, je l'ai trouvé sur Internet il y a des années et je ne peux malheureusement pas faire référence à l'auteur. Les deux autres ne sont que des extensions de la même idée.

Parce qu'ils sont typedef, rien n'est alloué. Avec le __LINE__ dans le nom, c'est toujours un nom différent afin qu'il puisse être copié et collé si nécessaire. Cela fonctionne dans les compilateurs MS Visual Studio C et les compilateurs GCC Arm. Cela ne fonctionne pas dans CodeWarrior, CW se plaint de la redéfinition, n'utilisant pas la construction de préprocesseur __LINE__.

//Check overall structure size
typedef char p__LINE__[ (sizeof(PARS) == 4184) ? 1 : -1];

//check 8 byte alignment for flash write or similar
typedef char p__LINE__[ ((sizeof(PARS) % 8) == 0) ? 1 : 1];

//check offset in structure to ensure a piece didn't move
typedef char p__LINE__[ (offsetof(PARS, SUB_PARS) == 912) ? 1 : -1];

Je sais que ce fil est vraiment vieux mais ...

Ma solution:

extern char __CHECK__[1/!(<<EXPRESSION THAT SHOULD COME TO ZERO>>)];

Tant que cette expression équivaut à zéro, elle se compile correctement. Tout le reste et ça explose juste là. Parce que la variable est externe, elle ne prendra pas d'espace, et tant que personne ne la référence (ce qui n'est pas le cas), cela ne provoquera pas d'erreur de lien.

Pas aussi flexible que la macro assert, mais je ne pouvais pas faire compiler cela dans ma version de GCC et cela le sera ... et je pense qu'il se compilera à peu près n'importe où.

Les réponses existantes montrent simplement comment obtenir l'effet des «assertions à la compilation» en fonction de la taille d'un type. Cela peut répondre aux besoins de l'OP dans ce cas particulier, mais il existe d'autres cas où vous avez vraiment besoin d'un préprocesseur conditionnel basé sur la taille d'un type. Voici comment procéder:

Écrivez-vous un petit programme C comme:

/* you could call this sizeof_int.c if you like... */
#include <stdio.h>
/* 'int' is just an example, it could be any other type */
int main(void) { printf("%zd", sizeof(int); }

Compilez ça. Écrivez un script dans votre langage de script préféré, qui exécute le programme C ci-dessus et capture sa sortie. Utilisez cette sortie pour générer un fichier d'en-tête C. Par exemple, si vous utilisiez Ruby, cela pourrait ressembler à:

sizeof_int = `./sizeof_int`
File.open('include/sizes.h','w') { |f| f.write(<<HEADER) }
/* COMPUTER-GENERATED, DO NOT EDIT BY HAND! */
#define SIZEOF_INT #{sizeof_int}
/* others can go here... */
HEADER

Ensuite, ajoutez une règle à votre Makefile ou à un autre script de construction, ce qui le fera exécuter le script ci-dessus pour construire sizes.h.

Incluez sizes.hlà où vous avez besoin d'utiliser des conditions de préprocesseur basées sur des tailles.

Terminé!

(Avez-vous déjà tapé ./configure && makepour créer un programme? Ce que configurefont les scripts est essentiellement comme ci-dessus ...)

Qu'en est-il de la prochaine macro:

/* 
 * Simple compile time assertion.
 * Example: CT_ASSERT(sizeof foo <= 16, foo_can_not_exceed_16_bytes);
 */
#define CT_ASSERT(exp, message_identifier) \
    struct compile_time_assertion { \
        char message_identifier : 8 + !(exp); \
    }

Par exemple, dans le commentaire, MSVC dit quelque chose comme:

test.c(42) : error C2034: 'foo_can_not_exceed_16_bytes' : type of bit field too small for number of bits

Juste à titre de référence pour cette discussion, je signale que certains compilateurs obtiennent sizeof () ar du temps pré-processeur.

La réponse de JamesMcNellis est correcte, mais certains compilateurs passent par cette limitation (cela viole probablement le strict ansi c).

Dans ce cas, je me réfère au compilateur IAR C (probablement le principal pour le microcontrôleur professionnel / la programmation embarquée).

#define SIZEOF(x) ((char*)(&(x) + 1) - (char*)&(x)) pourrait fonctionner

En C11, le _Static_assertmot clé est ajouté. Il peut être utilisé comme:

_Static_assert(sizeof(someThing) == PAGE_SIZE, "Data structure doesn't match page size")

Dans mon code c ++ portable ( http://www.starmessagesoftware.com/cpcclibrary/ ) je voulais mettre une garde sur la taille de certaines de mes structures ou classes.

Au lieu de trouver un moyen pour le préprocesseur de lancer une erreur (qui ne peut pas fonctionner avec sizeof () comme indiqué ici), j'ai trouvé ici une solution qui fait que le compilateur génère une erreur. http://www.barrgroup.com/Embedded-Systems/How-To/C-Fixed-Width-Integers-C99

J'ai dû adapter ce code pour qu'il génère une erreur dans mon compilateur (xcode):

static union
{
    char   int8_t_incorrect[sizeof(  int8_t) == 1 ? 1: -1];
    char  uint8_t_incorrect[sizeof( uint8_t) == 1 ? 1: -1];
    char  int16_t_incorrect[sizeof( int16_t) == 2 ? 1: -1];
    char uint16_t_incorrect[sizeof(uint16_t) == 2 ? 1: -1];
    char  int32_t_incorrect[sizeof( int32_t) == 4 ? 1: -1];
    char uint32_t_incorrect[sizeof(uint32_t) == 4 ? 1: -1];
};

Après avoir essayé les macros mentionnées, ce fragment semble produire le résultat souhaité ( t.h):

#include <sys/cdefs.h>
#define STATIC_ASSERT(condition) typedef char __CONCAT(_static_assert_, __LINE__)[ (condition) ? 1 : -1]
STATIC_ASSERT(sizeof(int) == 4);
STATIC_ASSERT(sizeof(int) == 42);

Courir cc -E t.h:

# 1 "t.h"
...
# 2 "t.h" 2

typedef char _static_assert_3[ (sizeof(int) == 4) ? 1 : -1];
typedef char _static_assert_4[ (sizeof(int) == 42) ? 1 : -1];

Courir cc -o t.o t.h:

% cc -o t.o t.h
t.h:4:1: error: '_static_assert_4' declared as an array with a negative size
STATIC_ASSERT(sizeof(int) == 42);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
t.h:2:84: note: expanded from macro 'STATIC_ASSERT'
  ...typedef char __CONCAT(_static_assert_, __LINE__)[ (condition) ? 1 : -1]
                                                       ^~~~~~~~~~~~~~~~~~~~
1 error generated.

42 n'est pas la réponse à tout après tout ...

Pour vérifier au moment de la compilation la taille des structures de données par rapport à leurs contraintes, j'ai utilisé cette astuce.

#if defined(__GNUC__)
{ char c1[sizeof(x)-MAX_SIZEOF_X-1]; } // brakets limit c1's scope
#else
{ char c1[sizeof(x)-MAX_SIZEOF_X]; }   
#endif

Si la taille de x est supérieure ou égale à sa limite MAX_SIZEOF_X, alors le gcc se plaindra d'une erreur «taille du tableau trop grande». VC ++ émettra soit l'erreur C2148 («la taille totale du tableau ne doit pas dépasser 0x7fffffff octets») soit C4266 «ne peut pas allouer un tableau de taille constante 0».

Les deux définitions sont nécessaires car gcc permettra de définir un tableau de taille zéro de cette façon (sizeof x - n).

L' sizeofopérateur n'est pas disponible pour le préprocesseur, mais vous pouvez transférer sizeofvers le compilateur et vérifier la condition à l'exécution:

#define elem_t double

#define compiler_size(x) sizeof(x)

elem_t n;
if (compiler_size(elem_t) == sizeof(int)) {
    printf("%d",(int)n);
} else {
    printf("%lf",(double)n);
}