consExpr + Multidimension Array schlägt fehl

Question

Ich habe Schwierigkeiten, consExpr im Kontext eines C++ - eingebauten mehrdimensionalen Arrays zu verstehen. Das folgende Beispiel veranschaulicht mein Problem.

a) Wenn ich einen Wert zur Kompilierzeit suche, funktioniert das so, wie ich es erwarte, solange ich ihm nichts zuordne.

b) Aber wenn ich versuche, es einer anderen constexpr-Variable zuzuweisen, erhalte ich einen Kompilierzeitfehler.

Ich habe mich umgesehen und sogar das Standarddokument überprüft. Jeder, der mir das erklären kann, ist wirklich ein Guru. FWIW, ich kompiliere dies mit CLang 8.1 unter Xcode mit C++ 14 aktiviert.

using uint8_t = unsigned char; 


#if 1 
enum class safe_numerics_error : uint8_t { 
    success = 0, 
    failure, // result is above representational maximum 
    error_count 
}; 
#else 
// avoiding enum class fails to solve problem 
struct safe_numerics_error { 
    const uint8_t m_t; 
    constexpr const static uint8_t success = 0; 
    constexpr const static uint8_t failure = 1; 
    constexpr safe_numerics_error(uint8_t t) : 
     m_t(t) 
    {} 
    constexpr operator uint8_t() const { 
     return m_t; 
    } 
}; 
#endif 

template<typename R> 
struct checked_result { 
    const safe_numerics_error m_e; 
    const union { 
     const R m_r; 
     char const * const m_msg; 
    }; 
    constexpr /*explicit*/ checked_result(const R & r) : 
     m_e(safe_numerics_error::success), 
     m_r(r) 
    {} 
    constexpr /*explicit*/ checked_result(const safe_numerics_error & e) : 
     m_e(e), 
     m_msg("") 
    {} 
}; 

// integers addition 
template<class T> 
constexpr inline checked_result<T> operator+(
    const checked_result<T> & t, 
    const checked_result<T> & u 
){ 
    // "Constexpr variable 'e' must be initialized by a constant expression" 
    constexpr const safe_numerics_error x[2][2]{ 
     // t == success 
     { 
      // u == ... 
      safe_numerics_error::success, 
      safe_numerics_error::failure 
     }, 
     // t == positive_overflow_error, 
     { 
      // u == ... 
      safe_numerics_error::failure, 
      safe_numerics_error::failure 
     } 
    }; 

#if 1 // compile fails 
    constexpr const safe_numerics_error e = x 
     [static_cast<uint8_t>(t.m_e)] 
     [static_cast<uint8_t>(u.m_e)] 
    ; 

    return 
     (safe_numerics_error::success == e) 
     ? t.m_r + u.m_r 
     : checked_result<T>(e) 
    ; 
#else // works as expected 
    return 
     safe_numerics_error::success == x 
      [static_cast<uint8_t>(t.m_e)] 
      [static_cast<uint8_t>(u.m_e)] 
     ? t.m_r + u.m_r 
     : checked_result<T>(x 
      [static_cast<uint8_t>(t.m_e)] 
      [static_cast<uint8_t>(u.m_e)] 
     ) 
    ; 
#endif 
} 

int main(){ 
    constexpr const checked_result<unsigned> i = 0; 
    constexpr const checked_result<unsigned> j = 0; 

    constexpr const checked_result<unsigned> k = i + j; 

    // return k.m_r; 

    constexpr const checked_result<unsigned> i2 = safe_numerics_error::failure; 
    constexpr const checked_result<unsigned> j2 = 0; 

    constexpr const checked_result<unsigned> k2 = i2 + j2; 
    return k2.m_r; 
} 

Answer 1

Das Problem ist, dass Sie keine constexpr Variable

constexpr const safe_numerics_error e = x 
    [static_cast<uint8_t>(t.m_e)] 
    [static_cast<uint8_t>(u.m_e)] 

mit einem Wert, der von einem Argument einer Funktion (oder Methode) (als t und u) hängen initialisieren.

Ich weiß, dass Ihr operator+() ein constexpr ist und dass Sie in Ihrem Beispiel es nur verwenden, um constexpr Werte zu initialisieren.

Aber eine constexpr Funktion/Methode kann kompiliert werden und Laufzeit. Daher kann ein Compiler keinen Code in einer constexpr-Funktion/Methode akzeptieren, die nicht zur Laufzeit ausgeführt werden kann.