How can I use "sizeof" in a preprocessor macro?

Is there anyway to use a "sizeof" in a pre-processor macro?

No. The conditional directives take a restricted set of conditional expressions; sizeof is one of the things not allowed.

Preprocessing directives are evaluated before the source is parsed (at least conceptually), so there aren't any types or variables yet to get their size.

However, there are techniques to getting compile-time assertions in C (for example, see this page).

I know it's a late answer, but to add on to Mike's version, here's a version we use that doesn't allocate any memory. I didn't come up with the original size check, I found it on the internet years ago and unfortunately can't reference the author. The other two are just extensions of the same idea.

Because they are typedef's, nothing is allocated. With the __LINE__ in the name, it's always a different name so it can be copied and pasted where needed. This works in MS Visual Studio C compilers, and GCC Arm compilers. It does not work in CodeWarrior, CW complains about redefinition, not making use of the __LINE__ preprocessor construct.

//Check overall structure sizetypedef char p__LINE__[ (sizeof(PARS) == 4184) ? 1 : -1];//check 8 byte alignment for flash write or similartypedef char p__LINE__[ ((sizeof(PARS) % 8) == 0) ? 1 : 1];//check offset in structure to ensure a piece didn't movetypedef char p__LINE__[ (offsetof(PARS, SUB_PARS) == 912) ? 1 : -1];

I know this thread is really old but...

My solution:

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

As long as that expression equates to zero, it compiles fine. Anything else and it blows up right there. Because the variable is extern'd it will take up no space, and as long as no-one references it (which they won't) it won't cause a link error.

Not as flexible as the assert macro, but I couldn't get that to compile in my version of GCC and this will... and I think it will compile just about anywhere.

The existing answers just show how to achieve the effect of "compile-time assertions" based on the size of a type. That may meet the OP's needs in this particular case, but there are other cases where you really need a preprocessor conditional based on the size of a type. Here's how to do it:

Write yourself a little C program like:

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

Compile that. Write a script in your favorite scripting language, which runs the above C program and captures its output. Use that output to generate a C header file. For example, if you were using Ruby, it might look like:

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

Then add a rule to your Makefile or other build script, which will make it run the above script to build sizes.h.

Include sizes.h wherever you need to use preprocessor conditionals based on sizes.

Done!

(Have you ever typed ./configure && make to build a program? What configure scripts do is basically just like the above...)

What about next 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); \}

For example in comment MSVC tells something like:

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

Just as a reference for this discussion, I report that some compilers get sizeof() ar pre-processor time.

JamesMcNellis answer is correct, but some compilers go through this limitation (this probably violates strict ansi c).

As a case of this, I refer to IAR C-compiler (probably the leading one for professional microcontroller/embedded programming).

#define SIZEOF(x) ((char*)(&(x) + 1) - (char*)&(x)) might work

In C11 _Static_assert keyword is added. It can be used like:

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

To check at compile time the size of data structures against their constraints I've used this trick.

#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

If x's size is greater or equal than it's limit MAX_SIZEOF_X, then the gcc wil complain with a 'size of array is too large' error. VC++ will issue either error C2148 ('total size of array must not exceed 0x7fffffff bytes') or C4266 'cannot allocate an array of constant size 0'.

The two definitions are needed because gcc will allow a zero-sized array to be defined this way (sizeof x - n).

In my portable c++ code ( http://www.starmessagesoftware.com/cpcclibrary/ ) wanted to put a safe guard on the sizes of some of my structs or classes.

Instead of finding a way for the preprocessor to throw an error ( which cannot work with sizeof() as it is stated here ), I found a solution here that causes the compiler to throw an error.http://www.barrgroup.com/Embedded-Systems/How-To/C-Fixed-Width-Integers-C99

I had to adapt that code to make it throw an error in my compiler (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];};

After trying out the mentioned macro's, this fragment seems to produce the desired result (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);

Running cc -E t.h:

# 1 "t.h"...# 2 "t.h" 2typedef char _static_assert_3[ (sizeof(int) == 4) ? 1 : -1];typedef char _static_assert_4[ (sizeof(int) == 42) ? 1 : -1];

Running cc -o t.o t.h:

% cc -o t.o t.ht.h:4:1: error: '_static_assert_4' declared as an array with a negative sizeSTATIC_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 isn't the answer to everything after all...

The sizeof operator is not available for the preprocessor, but you can transfer sizeof to the compiler and check the condition in runtime:

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