Как обеспечить, чтобы функция constexpr никогда не вызывалась во время выполнения?

Question

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

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

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

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

Или, в безопасности, скажем, функция занимает много времени, и вы хотите убедиться, что она никогда не происходит во время выполнения и вызывает плохой пользовательский интерфейс для ваших конечных пользователей.

Есть ли способ гарантировать, что функция constexpr никогда не будет вызвана во время выполнения? Или поочередно, бросать утверждение или подобное во время выполнения было бы хорошо, но не так идеально, как ошибка компиляции.

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

Отдаленно связанный с этим вопрос: Force constexpr to be evaluated at compile time

Answer 1

Вы можете заставить использовать его в постоянном выражении:

#include<utility> 

template<typename T, T V> 
constexpr auto ct() { return V; } 

template<typename T> 
constexpr auto func() { 
    return ct<decltype(std::declval<T>().value()), T{}.value()>(); 
} 

template<typename T> 
struct S { 
    constexpr S() {} 
    constexpr T value() { return T{}; } 
}; 

template<typename T> 
struct U { 
    U() {} 
    T value() { return T{}; } 
}; 

int main() { 
    func<S<int>>(); 
    // won't work 
    //func<U<int>>(); 
} 

Используя результат функции в качестве аргумента шаблона, вы получили сообщение об ошибке, если оно не может быть разрешено во время компиляции.

Answer 2

теоретическое решение (как шаблоны должны быть Тьюринга) - не использовать функции constexpr и падают обратно на старую-добрую std=c++0x стиль вычисления с использованием исключительно struct template with values. Например, не делайте

constexpr uintmax_t fact(uint n) { 
    return n>1 ? n*fact(n-1) : (n==1 ? 1 : 0); 
} 

но

template <uint N> struct fact { 
    uintmax_t value=N*fact<N-1>::value; 
} 
template <> struct fact<1> 
    uintmax_t value=1; 
} 
template <> struct fact<0> 
    uintmax_t value=0; 
} 

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

Тот факт, что ребята из boost смогли сделать compile time parser, является сильным сигналом, который, хотя и утомительный, должен быть осуществимым - это разовая стоимость, может быть, можно считать его инвестицией.

---

Например:

к мощности структуры:

// ***Warning: note the unusual order of (power, base) for the parameters 
// *** due to the default val for the base 
template <unsigned long exponent, std::uintmax_t base=10> 
struct pow_struct 
{ 
private: 
    static constexpr uintmax_t at_half_pow=pow_struct<exponent/2, base>::value; 
public: 
    static constexpr uintmax_t value= 
     at_half_pow*at_half_pow*(exponent % 2 ? base : 1) 
    ; 
}; 

// not necessary, but will cut the recursion one step 
template <std::uintmax_t base> 
struct pow_struct<1, base> 
{ 
    static constexpr uintmax_t value=base; 
}; 


template <std::uintmax_t base> 
struct pow_struct<0,base> 
{ 
    static constexpr uintmax_t value=1; 
}; 

Билд лексема

template <uint vmajor, uint vminor, uint build> 
struct build_token { 
    constexpr uintmax_t value= 
     vmajor*pow_struct<9>::value 
    + vminor*pow_struct<6>::value 
    + build_number 
    ; 
}