Wie kann ich “sizeof” in einem Präprozessormakro verwenden?

Gibt es eine Möglichkeit, a sizeof in einem Präprozessor-Makro?

Zum Beispiel gab es im Laufe der Jahre eine Menge Situationen, in denen ich so etwas tun wollte:

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

Das genaue, was ich hier überprüfe, ist vollständig erfunden – der Punkt ist, dass ich oft gerne diese Art von (Größe oder Ausrichtung) Kompilierzeitprüfungen einfüge, um zu verhindern, dass jemand eine Datenstruktur ändert, die falsch ausgerichtet oder neu ausgerichtet werden könnte. Größe Dinge, die sie zerbrechen würden.

Unnötig zu sagen – ich scheine nicht in der Lage zu sein, a zu verwenden sizeof in der oben beschriebenen Weise.

Dazu gibt es mehrere Möglichkeiten. Die folgenden Ausschnitte erzeugen keinen Code, wenn sizeof(someThing) gleich PAGE_SIZE; andernfalls erzeugen sie einen Kompilierzeitfehler.

1. C11-Weg

Ab C11 können Sie verwenden static_assert (erfordert #include <assert.h>).

Verwendungszweck:

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

2. Benutzerdefiniertes Makro

Wenn Sie nur einen Kompilierungsfehler erhalten möchten, wenn sizeof(something) nicht das ist, was Sie erwarten, können Sie folgendes Makro verwenden:

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

Verwendungszweck:

BUILD_BUG_ON( sizeof(someThing) != PAGE_SIZE );

Dieser Artikel erklärt ausführlich, warum es funktioniert.

3. MS-spezifisch

Auf Microsoft C++ Compiler können Sie verwenden C_ASSERT Makro (erfordert #include <windows.h>), die einen ähnlichen Trick wie den in Abschnitt 2 beschriebenen verwendet.

Verwendungszweck:

C_ASSERT(sizeof(someThing) == PAGE_SIZE);

Gibt es trotzdem eine “sizeof” in einem Präprozessor-Makro?

Nein. Die bedingten Direktiven akzeptieren eine eingeschränkte Menge bedingter Ausdrücke; sizeof ist eines der Dinge, die nicht erlaubt sind.

Vorverarbeitungsanweisungen werden ausgewertet, bevor die Quelle (zumindest konzeptionell) analysiert wird, sodass noch keine Typen oder Variablen vorhanden sind, die ihre Größe erhalten müssen.

Es gibt jedoch Techniken, um Assertions zur Kompilierzeit in C zu erhalten (siehe zum Beispiel diese Seite).

Ich weiß, es ist eine späte Antwort, aber um Mikes Version hinzuzufügen, verwenden wir hier eine Version, die keinen Speicher zuweist. Den Originalgrößencheck habe ich mir nicht ausgedacht, ich habe ihn vor Jahren im Internet gefunden und kann den Autor leider nicht nennen. Die anderen beiden sind nur Erweiterungen derselben Idee.

Da es sich um Typedefs handelt, wird nichts zugewiesen. Mit der __LINE__ im Namen ist es immer ein anderer Name, sodass er kopiert und bei Bedarf eingefügt werden kann. Dies funktioniert in MS Visual Studio C-Compilern und GCC-Arm-Compilern. Es funktioniert nicht in CodeWarrior, CW beschwert sich über die Neudefinition, die das Präprozessorkonstrukt __LINE__ nicht verwendet.

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

Ich weiß, dieser Thread ist wirklich alt, aber…

Meine Lösung:

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

Solange dieser Ausdruck gleich Null ist, wird er gut kompiliert. Alles andere und es explodiert genau dort. Da die Variable extern ist, nimmt sie keinen Platz ein, und solange niemand darauf verweist (was nicht der Fall ist), verursacht sie keinen Link-Fehler.

Nicht so flexibel wie das Assert-Makro, aber ich konnte das nicht in meiner Version von GCC kompilieren, und das wird … und ich denke, es wird fast überall kompiliert.

Die vorhandenen Antworten zeigen nur, wie Sie den Effekt von “Compile-Time-Assertionen” basierend auf der Größe eines Typs erzielen können. Das mag in diesem speziellen Fall die Anforderungen des OP erfüllen, aber es gibt andere Fälle, in denen Sie wirklich einen Präprozessor benötigen, der auf der Größe eines Typs basiert. So geht’s:

Schreiben Sie sich ein kleines C-Programm wie:

/* 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); }

Kompilieren Sie das. Schreiben Sie ein Skript in Ihrer bevorzugten Skriptsprache, das das obige C-Programm ausführt und dessen Ausgabe erfasst. Verwenden Sie diese Ausgabe, um eine C-Header-Datei zu generieren. Wenn Sie beispielsweise Ruby verwenden, könnte es so aussehen:

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

Fügen Sie dann eine Regel zu Ihrem Makefile oder einem anderen Build-Skript hinzu, wodurch das obige Skript zum Erstellen ausgeführt wird sizes.h.

Enthalten sizes.h überall dort, wo Sie Präprozessor-Bedingungen basierend auf Größen verwenden müssen.

Fertig!

(Haben Sie schon einmal getippt ./configure && make um ein Programm zu erstellen? Was configure Skripte tun, ist im Grunde genau wie oben …)

Was ist mit dem nächsten Makro:

/* 
 * 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); \
    }

Zum Beispiel sagt MSVC im Kommentar etwas wie:

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

Nur als Referenz für diese Diskussion berichte ich, dass einige Compiler sizeof() in der Präprozessorzeit erhalten.

Die Antwort von James McNellis ist richtig, aber einige Compiler gehen diese Einschränkung durch (dies verstößt wahrscheinlich gegen striktes Ansi c).

In diesem Fall beziehe ich mich auf den IAR C-Compiler (wahrscheinlich der führende für professionelle Mikrocontroller-/Embedded-Programmierung).