Comment puis-je utiliser “sizeof” dans une macro préprocesseur?

Il y a plusieurs façons de le faire.
Extraits suivants ne produisent pas de code si sizeof(someThing) est égal à PAGE_SIZE; sinon, ils vont produire une erreur de compilation.

1. C11 façon

De départ avec C11 vous pouvez utiliser static_assert (nécessite #include <assert.h>).

Utilisation:

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

2. Macro personnalisée

Si vous voulez juste pour obtenir une erreur de compilation lors de la sizeof(something) n'est pas ce que vous attendez, vous pouvez utiliser la macro suivante:

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

Utilisation:

BUILD_BUG_ON( sizeof(someThing) != PAGE_SIZE );

Cet article explique en détails pourquoi il fonctionne.

3. MS-spécifique

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

Utilisation:

C_ASSERT(sizeof(someThing) == PAGE_SIZE);

Je sais que c'est une réponse tardive, mais d'ajouter à Mike version, voici une version qui n'a pas d'allouer de la mémoire. Je ne suis pas venu jusqu'à la taille originale de vérifier, je l'ai trouvé sur internet il y a des années et, malheureusement, ne peut pas référence à l'auteur. Les deux autres sont juste des extensions de la même idée.

Parce qu'ils sont typedef est, rien n'est alloué. Avec l' _LIGNE ___ dans le nom, c'est toujours un nom différent, de sorte qu'il peut être copié et collé en cas de besoin. Cela fonctionne sous MS Visual Studio C compilateurs, et GCC Bras de compilateurs. Il ne fonctionne pas dans CodeWarrior, CW se plaint de redéfinition, ne faisant pas usage de l' _LIGNE ___ préprocesseur construire.

//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];

L'existant réponses juste montrer comment faire pour obtenir l'effet de la "compilation des affirmations en fonction de la taille d'un type. Qui peut répondre à l'OP, dans ce cas particulier, mais il existe d'autres cas où vous avez vraiment besoin d'un préprocesseur conditionnelle basée sur la taille du type. Voici comment le faire:

Écrire vous-même 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); }

Compiler que. Écrire un script dans votre langage de script favori, qui exécute le programme C ci-dessus et obtient sa sortie. Utilisez cette sortie pour générer un fichier en-tête C. Par exemple, si vous étiez à l'aide de Ruby, il 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

Puis ajouter une règle à votre Makefile ou un autre script de construction, ce qui va la faire exécuter le script ci-dessus pour construire sizes.h.

Inclure sizes.h partout où vous avez besoin d'utiliser le préprocesseur conditionnelles basées sur les tailles.

Fait!

(Avez-vous déjà tapé ./configure && make de bâtir un programme? Ce configure scripts n'est fondamentalement juste comme ci-dessus...)

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

En C11 _Static_assert mot-clé est ajouté. Il peut être utilisé comme:

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