Обнаружение времени компиляции или выполнения в функции constexpr

Можно определить, является ли данное выражение вызова функции постоянным выражением, и, таким образом, выбрать между двумя различными реализациями. Требуется C ++ 14 для общей лямбды, используемой ниже.

(Этот ответ вырос из ответа @Yakk на вопрос, который я задал в прошлом году).

Я не уверен, насколько далеко я продвигаю Стандарт. Это проверено на clang 3.9, но приводит к тому, что g ++ 6.2 выдает «внутреннюю ошибку компилятора». Я пришлю отчет об ошибке на следующей неделе (если никто не сделает это первым!)

Этот первый шаг - переместить реализацию constexpr в struct как метод constexpr static. Проще говоря, вы можете оставить текущий constexpr как есть и вызвать его из метода constexpr static нового struct.

struct StaticStruct {
    static constexpr float MyMin_constexpr (float a, float b) {
        return a<b?a:b;
    }
};

Также определите это (даже если это выглядит бесполезным!):

template<int>
using Void = void;

Основная идея состоит в том, что Void<i> требует, чтобы i было постоянным выражением. Точнее, эта следующая лямбда будет иметь подходящие перегрузки только при определенных обстоятельствах:

auto l = [](auto ty)-> Void<(decltype(ty)::   MyMin_constexpr(1,3)   ,0)>{};
                                              \------------------/
                                               testing if this
                                               expression is a
                                               constant expression.

Мы можем вызвать l, только если аргумент ty имеет тип StaticStruct и, если наше выражение интереса (MyMin_constexpr(1,3)) является постоянным выражением. Если мы заменим 1 или 3 непостоянными аргументами, то общая лямбда l потеряет метод через SFINAE.

Следовательно, следующие два теста эквивалентны:

• StaticStruct::MyMin_constexpr(1,3) - это постоянное выражение?
• Можно ли вызвать l через l(StaticStruct{})?

Заманчиво просто удалить auto ty и decltype(ty) из приведенной выше лямбды. Но это приведет к серьезной ошибке (в непостоянном случае) вместо хорошей ошибки подстановки. Поэтому мы используем auto ty, чтобы получить ошибку замены (которую мы можем с пользой обнаружить) вместо ошибки.

Следующий код просто возвращает std:true_type тогда и только тогда, когда f (наша общая лямбда) может быть вызвана с a (StaticStruct):

template<typename F,typename A>
constexpr
auto
is_a_constant_expression(F&& f, A&& a)
    -> decltype( ( std::forward<F>(f)(std::forward<A>(a)) , std::true_type{} ) )
{ return {}; }
constexpr
std::false_type is_a_constant_expression(...)
{ return {}; }

Далее демонстрация его использования:

int main() {
    {
        auto should_be_true = is_a_constant_expression(
            [](auto ty)-> Void<(decltype(ty)::   MyMin_constexpr(1,3)   ,0)>{}
            , StaticStruct{});
        static_assert( should_be_true ,"");
    }
    {   
        float f = 3; // non-constexpr
        auto should_be_false = is_a_constant_expression(
            [](auto ty)-> Void<(decltype(ty)::   MyMin_constexpr(1,f)   ,0)>{}
            , StaticStruct{});
        static_assert(!should_be_false ,"");
    }
}

Чтобы решить вашу исходную проблему напрямую, мы могли бы сначала определить макрос для сохранения повторений:

(Я не тестировал этот макрос, извиняюсь за опечатки.)

#define IS_A_CONSTANT_EXPRESSION( EXPR )                \
     is_a_constant_expression(                          \
         [](auto ty)-> Void<(decltype(ty)::             \
              EXPR                         ,0)>{}       \
         , StaticStruct{})

На этом этапе, возможно, вы могли бы просто сделать:

#define MY_MIN(...)                                            \
    IS_A_CONSTANT_EXPRESSION( MyMin_constexpr(__VA_ARGS__) ) ? \
        StaticStruct :: MyMin_constexpr( __VA_ARGS__ )     :   \
                        MyMin_runtime  ( __VA_ARGS__ )

или, если вы не доверяете своему компилятору оптимизацию с std::true_type и с std::false_type по ?:, то, возможно,:

constexpr
float MyMin(std::true_type, float a, float b) { // called if it is a constant expression
    return StaticStruct:: MyMin_constexpr(a,b);
}
float MyMin(std::false_type, float , float ) { // called if NOT a constant expression
    return                MyMin_runtime(a,b);
}

с этим макросом вместо этого:

#define MY_MIN(...)                                             \
  MyMin( IS_A_CONSTANT_EXPRESSION(MyMin_constexpr(__VA_ARGS__)) \
       , __VA_ARGS__)

Я подумал, что это будет способ гарантировать, что MyMin может когда-либо использоваться только с константами, оцениваемыми во время компиляции, и это гарантирует, что компилятор никогда не разрешит его выполнение во время выполнения.

Да; есть выход.

И работает с C ++ 11.

Google-ing Я нашел странный способ отравления (Скотт Шурр ): короче, следующие

extern int no_symbol;

constexpr float MyMin (float a, float b)
 {
   return a != a ? throw (no_symbol)
                 : (a < b ? a : b) ;
 }

int main()
 {
   constexpr  float  m0 { MyMin(2.0f, 3.0f) }; // OK

   float  f1 { 2.0f };

   float  m1 { MyMin(f1, 3.0f) };  // linker error: undefined "no_symbol"
 }

Если я хорошо понимаю, идея заключается в том, что если MyMin() выполняется во время компиляции, throw(no_symbol) никогда не используется (a != a всегда ложно), поэтому нет необходимости использовать no_symbol, который объявлен extern, но никогда не определяется (и throw() не может использоваться время компиляции).

Если вы используете MyMin() время выполнения, throw(no_symbol) компилируется и no_symbol выдает ошибку на этапе компоновки.

В более общем плане существует предложение ( когда-либо от Скотта Шурра), но я не знаю о реализациях.

--- ИЗМЕНИТЬ ---

Как указал T.C. (спасибо!) это решение работает (если работает и когда работает) только потому, что компилятор не выполняет оптимизацию, чтобы понять, что a != a всегда ложно.

В частности, MyMin() работает (без хорошей оптимизации), потому что в этом примере мы работаем с числами с плавающей запятой и a != a может быть истинным, если a равно NaN, поэтому компилятору сложнее определить, что часть throw() не используется. Если MyMin() - функция для целых чисел, тело может быть записано (с проверкой float(a) != float(a), чтобы попытаться помешать оптимизации компилятора) как

constexpr int MyMin (int a, int b)
 {
   return float(a) != float(a) ? throw (no_symbol)
                 : (a < b ? a : b) ;
 }

но это не настоящее решение для функции, в которой нет "естественных" ошибок, которые могут быть выброшены.

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

Пример: если MyMin() возвращает минимальное значение между a и b, но a и b должны быть разными, или MyMin() должен выдавать ошибку компилятора (не лучший пример ... я знаю), поэтому

constexpr float MyMin (float a, float b)
 {
   return a != b ? throw (no_symbol)
                 : (a < b ? a : b) ;
 }

работает, потому что компилятор не может оптимизировать a != b и должен компилировать (с ошибкой компоновщика) часть throw().