Как я могу использовать sizeof в макросе препроцессора?

Есть ли способ использовать a sizeofв макросе препроцессора?

Например, за эти годы было множество ситуаций, в которых я хотел сделать что-то вроде:

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

То, что я здесь проверяю, полностью выдумано - дело в том, что я часто люблю вставлять эти типы (размер или выравнивание) проверок времени компиляции, чтобы защититься от того, кто-то изменит структуру данных, которая может смещаться или повторно размер вещей, которые могут их сломать.

Излишне говорить - похоже, что я не могу использовать a sizeofописанным выше способом.

Есть несколько способов сделать это. Следующие ниже фрагменты кода не будут создавать кода, если они sizeof(someThing)равны PAGE_SIZE; в противном случае они вызовут ошибку времени компиляции.

1. Способ C11

Начиная с C11 можно использовать static_assert(требуется #include <assert.h>).

Использование:

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

2. Пользовательский макрос

Если вы просто хотите получить ошибку времени компиляции, когда sizeof(something)это не то, чего вы ожидаете, вы можете использовать следующий макрос:

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

Использование:

BUILD_BUG_ON( sizeof(someThing) != PAGE_SIZE );

В этой статье подробно объясняется, почему это работает.

3. Специфичные для MS

В компиляторе Microsoft C ++ вы можете использовать макрос C_ASSERT (требуется #include <windows.h>), который использует прием, аналогичный тому, который описан в разделе 2.

Использование:

C_ASSERT(sizeof(someThing) == PAGE_SIZE);

Есть ли способ использовать " sizeof" в макросе препроцессора?

Нет. Условные директивы принимают ограниченный набор условных выражений; sizeofэто одна из недопустимых вещей.

Директивы предварительной обработки оцениваются до анализа источника (по крайней мере, концептуально), поэтому пока нет никаких типов или переменных, чтобы получить их размер.

Однако существуют методы получения утверждений времени компиляции в C (например, см. Эту страницу ).

Я знаю, что это поздний ответ, но чтобы добавить к версии Майка, вот версия, которую мы используем, которая не выделяет никакой памяти. Я не придумал проверку оригинального размера, я нашел ее в Интернете много лет назад и, к сожалению, не могу ссылаться на автора. Два других - просто продолжение той же идеи.

Поскольку они относятся к typedef, ничего не выделяется. С __LINE__ в имени это всегда другое имя, поэтому его можно скопировать и вставить там, где это необходимо. Это работает в компиляторах MS Visual Studio C и компиляторах GCC Arm. Это не работает в CodeWarrior, CW жалуется на переопределение, не используя конструкцию препроцессора __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];

Я знаю, что эта ветка действительно старая, но ...

Мое решение:

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

Пока это выражение равно нулю, оно компилируется нормально. Что-нибудь еще, и оно тут же взорвется. Поскольку переменная extern'd, она не будет занимать места, и пока на нее никто не ссылается (а они не будут), это не вызовет ошибку ссылки.

Не такой гибкий, как макрос assert, но я не смог заставить его скомпилировать в моей версии GCC, и это будет ... и я думаю, что он будет компилироваться где угодно.

Существующие ответы просто показывают, как добиться эффекта «утверждений времени компиляции» в зависимости от размера типа. Это может удовлетворить потребности OP в данном конкретном случае, но есть и другие случаи, когда вам действительно нужен условный препроцессор, основанный на размере типа. Вот как это сделать:

Напишите себе небольшую программу на C, например:

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

Скомпилируйте это. Напишите сценарий на вашем любимом языке сценариев, который запускает указанную выше программу C и фиксирует ее вывод. Используйте этот вывод для создания файла заголовка C. Например, если вы использовали Ruby, это могло бы выглядеть так:

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

Затем добавьте правило в свой Makefile или другой скрипт сборки, которое заставит его запустить приведенный выше скрипт для сборки sizes.h.

Включайте sizes.hвезде, где вам нужно использовать условные выражения препроцессора на основе размеров.

Готово!

(Вы когда-нибудь печатали ./configure && makeдля создания программы? Что configureделают скрипты, в основном такие же, как и выше ...)

А как насчет следующего макроса:

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

Например, в комментарии MSVC сообщает что-то вроде:

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

В качестве ссылки для этого обсуждения я сообщаю, что некоторые компиляторы получают время препроцессора sizeof () ar.

Ответ Джеймса МакНеллиса правильный, но некоторые компиляторы проходят через это ограничение (это, вероятно, нарушает строгий ответ).

В качестве примера я имею в виду C-компилятор IAR (вероятно, ведущий для профессионального программирования микроконтроллеров / встроенных программ).

#define SIZEOF(x) ((char*)(&(x) + 1) - (char*)&(x)) может работать

В C11 _Static_assertдобавлено ключевое слово. Его можно использовать как:

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

В моем переносимом коде на C ++ ( http://www.starmessagesoftware.com/cpcclibrary/ ) я хотел защитить размеры некоторых из моих структур или классов.

Вместо того, чтобы найти способ, чтобы препроцессор выдал ошибку (которая не может работать с sizeof (), как указано здесь), я нашел здесь решение, которое заставляет компилятор выдавать ошибку. http://www.barrgroup.com/Embedded-Systems/How-To/C-Fixed-Width-Integers-C99

Мне пришлось адаптировать этот код, чтобы он выдавал ошибку в моем компиляторе (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];
};

После тестирования упомянутого макроса этот фрагмент, похоже, дает желаемый результат ( 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);

Бег 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];

Бег 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 - это не ответ на все вопросы ...

Чтобы проверить во время компиляции размер структур данных на соответствие их ограничениям, я использовал этот трюк.

#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

Если размер x больше или равен предельному значению MAX_SIZEOF_X, тогда gcc будет жаловаться на ошибку «размер массива слишком большой». VC ++ выдаст либо ошибку C2148 («общий размер массива не должен превышать 0x7fffffff байтов»), либо C4266 «не может выделить массив постоянного размера 0».

Эти два определения необходимы, потому что gcc позволит таким образом определить массив нулевого размера (sizeof x - n).

sizeofОператор не доступен для препроцессора, но вы можете передать sizeofкомпилятору и проверить состояние во время выполнения:

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