Alternativa alle affermazioni per le funzioni di constexpr

Question

Ho alcune brevi funzioni constexpr nelle mie librerie che eseguono alcuni semplici calcoli. Li uso entrambi in contesti run-time e in fase di compilazione.

Desidero eseguire alcune affermazioni nel corpo di queste funzioni, tuttavia assert(...) non è valido in una funzione constexpr e static_assert(...) non può essere utilizzato per controllare i parametri di funzione.

Esempio:

constexpr int getClamped(int mValue, int mMin, int mMax) noexcept 
{ 
    assert(mMin <= mMax); // does not compile! 
    return mValue < mMin ? mMin : (mValue > mMax ? mMax : mValue); 
} 

C'è un modo per controllo se la funzione è stata eseguita in un runtime o fase di compilazione costante ed eseguire la assert solo se è in esecuzione in fase di esecuzione ?

constexpr int getClamped(int mValue, int mMin, int mMax) noexcept 
{ 
    assert_if_runtime(mMin <= mMax); 
    return mValue < mMin ? mMin : (mValue > mMax ? mMax : mValue); 
} 

Answer 1

Credo che assert funzionerà per voi una volta che g ++ implementa N3652, Relaxing constraints on constexpr functions. Attualmente, this status page indica che questo non è stato ancora implementato.

assert funziona (in funzioni constexpr) sull'attuale compilatore clang spedito da Apple, con -std=c++1y.

In questo momento, non vedo nulla nello standard che assicuri che assert funzioni nelle funzioni di constexpr e tale garanzia sarebbe una gradita aggiunta allo standard (almeno per me).

Aggiornamento

Richard Smith ha attirato la mia attenzione LWG 2234 presentata da Daniel Krugler che sta cercando di creare la certezza mi riferisco a sopra.

Answer 2

un'eccezione potrebbe essere utile come il compilatore ignorerà la parte di run-time quando si sa al momento della compilazione che l'eccezione non viene generata.

#include <cassert> 

constexpr int getClamped(int mValue, int mMin, int mMax) 
{ 
    return (mMin <= mMax) ? 
      (mValue < mMin ? mMin : (mValue > mMax ? mMax : mValue)) : 
      throw "mMin must be less than or equal to mMax"; 
} 

int main(int argc, char** argv) 
{ 
    // These two work: 
    static_assert(getClamped(42, 0, 100) == 42, "CT"); 
    assert(getClamped(argc, 0, 100) == argc); 

    // Fails at compile-time: 
    // static_assert(getClamped(42, 100, 0) == 42, "CT"); 

    // Fails at run-time: 
    // assert(getClamped(argc, 100, 0) == argc); 
} 

Live example

Answer 3

Un perfezionamento sulla risposta di Daniel Frey è quello di utilizzare noexcept sulla funzione constexpr di trasformare l'errore di runtime in una chiamata a std::terminate. I fallimenti delle asserzioni sono irrecuperabili; dovrebbero fermare immediatamente il processo. Trasformarli in eccezioni è una pessima idea.

#include <exception> 
#include <stdexcept> 

struct assert_failure 
    : std::logic_error 
{ 
    explicit assert_failure(const char *sz) 
     : std::logic_error(sz) 
    {} 
}; 

constexpr bool in_range(int i, int j, int k) noexcept 
{ 
    return (i <= j && j <= k) ? true : throw assert_failure("input not in range"); 
} 

int main(int argc, char* argv[]) 
{ 
    constexpr bool b1 = in_range(0, 4, 5); // OK! 
    constexpr bool b2 = in_range(0, 6, 5); // Compile-time error! 
    bool b3 = in_range(0, 4, argc);  // May or may not terminate the process 
} 

L'errore di runtime per me assomiglia:

terminate called after throwing an instance of 'assert_failure' 
    what(): input not in range 
Aborted (core dumped) 

Speranza che aiuta.