Wie kann ich "sizeof" in einem Präprozessor-Makro verwenden?

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

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

#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 häufig diese Arten von Überprüfungen zur Kompilierungszeit (Größe oder Ausrichtung) einsetze, um zu verhindern, dass jemand eine Datenstruktur ändert, die falsch ausgerichtet oder neu ausgerichtet werden könnte Größe Dinge, die sie brechen würden.

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

Es gibt verschiedene Möglichkeiten, dies zu tun. Das Folgen von Snippets erzeugt keinen Code, wenn er sizeof(someThing)gleich ist PAGE_SIZE. Andernfalls wird ein Fehler beim Kompilieren erzeugt.

1. C11 Weg

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

Verwendung:

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

2. Benutzerdefiniertes Makro

Wenn Sie nur einen Fehler beim Kompilieren erhalten möchten, wenn dies sizeof(something)nicht Ihren Erwartungen entspricht, können Sie das folgende Makro verwenden:

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

Verwendung:

BUILD_BUG_ON( sizeof(someThing) != PAGE_SIZE );

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

3. MS-spezifisch

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

Verwendung:

C_ASSERT(sizeof(someThing) == PAGE_SIZE);

Gibt es überhaupt ein " sizeof" in einem Vorprozessor-Makro?

Nein. Die bedingten Anweisungen enthalten nur eingeschränkte bedingte Ausdrücke. sizeofist eines der Dinge, die nicht erlaubt sind.

Vorverarbeitungsanweisungen werden ausgewertet, bevor die Quelle analysiert wird (zumindest konzeptionell), sodass noch keine Typen oder Variablen vorhanden sind, um ihre Größe zu ermitteln.

Es gibt jedoch Techniken, um Zusicherungen zur Kompilierungszeit in C abzurufen (siehe beispielsweise diese Seite ).

Ich weiß, dass es eine späte Antwort ist, aber um Mikes Version zu erweitern, hier ist eine Version, die wir verwenden und die keinen Speicher zuweist. Ich habe mir den Originalgrößencheck nicht ausgedacht, ich habe ihn vor Jahren im Internet gefunden und kann den Autor leider nicht referenzieren. 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 bei Bedarf kopiert und eingefügt werden kann. Dies funktioniert in MS Visual Studio C-Compilern und GCC Arm-Compilern. In CodeWarrior funktioniert es nicht. CW beschwert sich über eine Neudefinition und verwendet das Präprozessorkonstrukt __LINE__ nicht.

//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ß, dass dieser Thread wirklich alt ist, 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 sie nicht tun), verursacht sie keinen Linkfehler.

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

Die vorhandenen Antworten zeigen nur, wie der Effekt von "Zusicherungen zur Kompilierungszeit" basierend auf der Größe eines Typs erzielt werden kann. Dies mag in diesem speziellen Fall den Anforderungen des OP entsprechen, aber es gibt andere Fälle, in denen Sie wirklich einen Präprozessor benötigen, der von der Größe eines Typs abhängig ist. 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); }

Kompiliere 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, sieht es möglicherweise so aus:

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 Ihrem Makefile oder einem anderen Build-Skript eine Regel hinzu, mit der das oben zu erstellende Skript ausgeführt wird sizes.h.

Fügen sizes.hSie ein, wo immer Sie Präprozessor-Bedingungen verwenden müssen, die auf Größen basieren.

Getan!

(Haben Sie jemals geschrieben ./configure && make, um ein Programm zu erstellen? Was configureSkripte 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 () ar Pre-Prozessor-Zeit erhalten.

Die Antwort von JamesMcNellis ist korrekt, aber einige Compiler gehen diese Einschränkung durch (dies verstößt wahrscheinlich gegen strenge Ansi c).

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

#define SIZEOF(x) ((char*)(&(x) + 1) - (char*)&(x)) könnte funktionieren

In C11 wird ein _Static_assertSchlüsselwort hinzugefügt. Es kann verwendet werden wie:

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

In meinem portablen C ++ - Code ( http://www.starmessagesoftware.com/cpcclibrary/ ) wollte ich die Größe einiger meiner Strukturen oder Klassen sicher schützen.

Anstatt eine Möglichkeit für den Präprozessor zu finden, einen Fehler auszulösen (der nicht mit sizeof () funktioniert, wie hier angegeben), habe ich hier eine Lösung gefunden, die den Compiler veranlasst, einen Fehler auszulösen. http://www.barrgroup.com/Embedded-Systems/How-To/C-Fixed-Width-Integers-C99

Ich musste diesen Code anpassen, damit ein Fehler in meinem Compiler (xcode) ausgelöst wurde:

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

Nach dem Ausprobieren der genannten Makros scheint dieses Fragment das gewünschte Ergebnis zu liefern (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);

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

Laufen 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 ist doch nicht die Antwort auf alles ...

Der sizeofOperator ist für den Präprozessor nicht verfügbar, aber Sie können sizeofzum Compiler übertragen und die Bedingung zur Laufzeit überprüfen:

#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);
}