Макрос для использования в выражении при применении своих аргументов для компиляции констант времени

Question

Я ищу способ #define макроса, который принудительно применяет его аргументы для компиляции констант времени и в то же время может использоваться в выражении. Этот метод должен работать под управлением C90 и быть совместимым с повышением, если возможно, также переносимым для разных вариантов C++. Также предпочтительнее использовать 0-footprint для памяти.

В качестве примера рассмотрим макрос минимального времени компиляции. Поведение должно быть:

#define CT_MIN(CTC_A, CTC B) <<<MAGIC>>> 

int a = 1; 
int b = a + CT_MIN(1,4); /* OK */ 
int c = a + CT_MIN(a,4); /* COMPILER DIAGNOSTIC */ 

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

typedef char ct_check_is_ct_constant[(CTC_A != 0) + 1]; 

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

Я предположил бы, что-то в строках:

#define CT_MIN(CTC_A, CTC_B)     \ 
     (<expr check CTC_A>,     \ 
      <expr check CTC_B>,     \ 
      (CTC_A) < (CTC_B))? (CTC_A) : (CTC_B) \ 
     ) 

Но я понятия не имею, как выражения должны выглядеть, и если такая вещь существует.

Любые идеи?

фона:

У меня есть огромное количество констант из не слишком много надежных источников через costumized заголовка. Эти константы сильно параметризуют мой код. Я хочу реализовать проверку нулевого следа во время препроцессора и время компиляции для этих констант, чтобы проверить как мои предположения, среду, так и мои навыки, чтобы написать правильный генератор кода.

Answer 1

Вы можете использовать sizeof применительно к анонимной структуры с одним полем, тип которого является локально определенные enum, значения которого должны быть постоянные целые выражения:

#define CT_MIN(CTC_A, CTC_B)            \ 
    (sizeof(struct { enum { must_be_constant_expression = CTC_A } x; }), \ 
     sizeof(struct { enum { must_be_constant_expression = CTC_B } x; }), \ 
     (CTC_A) < (CTC_B) ? (CTC_A) : (CTC_B)        ) 

Сообщения об ошибках, полученные лязгом очень четко:

enumassert.c:32:24: error: expression is not an integer constant expression 
    int c = a + CT_MIN(a,4); /* COMPILER DIAGNOSTIC */ 
        ^
enumassert.c:17:60: note: expanded from macro 'CT_MIN' 
    (sizeof(struct { enum { must_be_constant_expression = CTC_A } x; }), \ 
                 ^

Это решение, похоже, не добавляет символ в пространство имен. Кроме того, если вам нужно обрабатывать случаи целочисленных типов, цена сообщения немного менее точной ошибки, вы можете добавить актер, как это:

#define CT_MIN(CTC_A, CTC_B)            \ 
    (sizeof(struct { enum { must_be_constant_expression = (int)(CTC_A) } x; }), \ 
     sizeof(struct { enum { must_be_constant_expression = (int)(CTC_B) } x; }), \ 
     (CTC_A) < (CTC_B) ? (CTC_A) : (CTC_B)        ) 

Answer 2

Для оценки как с плавающей точкой и целым во время компиляции константы I думаю, я могу использовать решение @ chqrlie и немного его обновить.

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

sizeof(struct { enum { must_be_constant_expression = (int) (!(CTC_A))} x; }) 

(! Я не уверен, что если унарный дает выход в int или что-то типа CTC_A)

Это должно обрабатывать большую часть всего, что операция MIN может быть разумно выполнена во время компиляции.затем

Полные макросъемки:

#define CT_MIN(CTC_A, CTC_B)               \ 
    (sizeof(struct { enum { must_be_constant_expression = (int) (!(CTC_A)) } x; }), \ 
     sizeof(struct { enum { must_be_constant_expression = (int) (!(CTC_B)) } x; }), \ 
     (CTC_A) < (CTC_B) ? (CTC_A) : (CTC_B)           \ 
    )