Wie zwischen assert () und static_assert () zu versenden, hängt davon ab, ob im constexpr-Kontext?

In C ++ 11 constexpr-Funktionen ist eine zweite Anweisung wie eine assert()nicht möglich. A static_assert()ist in Ordnung, würde aber nicht funktionieren, wenn die Funktion als "normale" Funktion aufgerufen wird. Der Komma-Operator könnte kommen, um wrto zu helfen. Das assert()ist aber hässlich und einige Tools spucken Warnungen darüber aus.

Betrachten Sie einen solchen "Getter", der neben der Behauptung durchaus verständlich ist. Aber ich möchte eine Art Zusicherung für die Laufzeit und die Kompilierungszeit behalten, kann aber nicht einfach überladen, abhängig vom Kontext 'constexpr'.

template<int Size>
struct Array {
  int m_vals[Size];
  constexpr const int& getElement( int idx ) const
  {
    ASSERT( idx < Size ); // a no-go for constexpr funcs in c++11
    // not possible, even in constexpr calls as being pointed out, but what I would like:
    static_assert( idx < Size, "out-of-bounds" );
    return m_vals[idx];
  }
};

Nebenbedingungen: C ++ 11, kein Heap, keine Ausnahmen, keine Compilerspezifikationen.

Beachten Sie, wie Kommentatoren betonten (danke!), static_assertDas Argument ist nicht möglich (wäre aber nett). Der Compiler hat mir in dieser Situation einen anderen Fehler beim Zugriff außerhalb der Grenzen gemeldet.

Etwas wie

void assert_impl() { assert(false); } // Replace body with own implementation

#ifdef NDEBUG // Replace with own conditional
#define my_assert(condition) ((void)0)
#else
#define my_assert(condition) ((condition) ? (void()) : (assert_impl(), void()))
#endif

template<int Size>
struct Array {
  int m_vals[Size];
  constexpr const int& getElement( int idx ) const
  {
    return my_assert(idx < Size), m_vals[idx];
  }
};

Es wird ein Kompilierungszeitfehler bei einem Assertionsfehler ausgegeben, wenn es in einem Kontext verwendet wird , der einen konstanten Ausdruck erfordert (weil es eine Nichtfunktion aufruft constexpr).

Andernfalls schlägt es zur Laufzeit mit einem Aufruf von assert(oder Ihrem Analog) fehl .

Soweit ich weiß, ist dies das Beste, was Sie tun können. Es gibt keine Möglichkeit, den Wert von idxzu verwenden, um eine Überprüfung zur Kompilierungszeit außerhalb des Kontexts zu erzwingen , der konstante Ausdrücke erfordert .

Die Syntax des Kommaoperators ist nicht gut, aber die C ++ 11- constexprFunktionen sind sehr eingeschränkt.

Wie Sie bereits bemerkt haben, wird undefiniertes Verhalten natürlich trotzdem diagnostiziert, wenn die Funktion in einem Kontext verwendet wird, der einen konstanten Ausdruck erfordert.

Wenn Sie wissen, dass assert(oder Ihr Analogon) sich nicht auf etwas erweitert, das in einem konstanten Ausdruck verboten ist, wenn die Bedingung ausgewertet wird, truesondern wenn dies ausgewertet wird false, können Sie es direkt verwenden, anstatt die von my_assertmir erstellte Indirektion zu überspringen in meinem Code.

Besser als ein Komma-Ausdruck können Sie eine ternäre Bedingung verwenden. Der erste Operand ist Ihr Assertionsprädikat, der zweite Operand ist Ihr Erfolgsausdruck. Da der dritte Operand ein beliebiger Ausdruck sein kann - auch einer, der in einem konstanten C ++ 11-Kontext nicht verwendet werden kann -, können Sie mit einem Lambda die ASSERTEinrichtung Ihrer Bibliothek aufrufen :

#define ASSERT_EXPR(pred, success)    \
    ((pred) ?                         \
     (success) :                      \
     [&]() -> decltype((success))     \
     {                                \
         ASSERT(false && (pred));     \
         struct nxg { nxg() {} } nxg; \
         return (success);            \
     }())

Erklärung des Lambda-Körpers:

• ASSERT(false && (pred)) soll sicherstellen, dass Ihre Assertionsmaschinerie mit einem geeigneten Ausdruck (zur Stringifizierung) aufgerufen wird.
• struct nxg { nxg() {} } nxgdient der Zukunftssicherheit, um sicherzustellen, dass beim Kompilieren in C ++ 17 oder höher NDEBUGdas Lambda immer noch nicht vorhanden ist constexprund die Behauptung daher im Kontext der Konstantenbewertung erzwungen wird.
• return (success)gibt es aus zwei Gründen: um sicherzustellen, dass der zweite und der dritte Operand den gleichen Typ haben, und damit NDEBUGder successAusdruck unabhängig davon zurückgegeben wird , ob Ihre Bibliothek dies respektiert pred. ( predwird ausgewertet , aber Sie hoffen, dass Assertionsprädikate billig zu bewerten sind und keine Nebenwirkungen haben.)

Anwendungsbeispiel:

template<int Size>
struct Array {
  int m_vals[Size];
  constexpr int getElement( int idx ) const
  {
    return ASSERT_EXPR(idx < Size, m_vals[idx]);
  }
};

constexpr int I = Array<2>{1, 2}.getElement(1); // OK
constexpr int J = Array<2>{1, 2}.getElement(3); // fails

static_assertkann hier nicht verwendet werden. Das Argument für eine constexprFunktion ist in einem Konstantenausdruck nicht zulässig. Daher gibt es unter den angegebenen Bedingungen keine Lösung für Ihr Problem .

Wir können das Problem jedoch lösen, indem wir zwei Einschränkungen biegen

1. nicht verwenden static_assert(verwenden Sie stattdessen andere Methoden, um eine Diagnose zur Kompilierungszeit zu erstellen) und

2. Ignorieren Sie, dass der Komma-Operator "hässlich ist und einige Tools Warnungen darüber ausspucken". (Das Zeigen seiner Hässlichkeit ist eine unglückliche Folge der strengen Anforderungen der C ++ 11- constexprFunktionen.)

Dann können wir ein normales verwenden assert:

template <int Size>
struct Array {
  int m_vals[Size];
  constexpr const int& getElement(int idx) const
  {
    return assert(idx < Size), m_vals[idx];
  }
};

In einem konstanten Auswertungskontext wird dies einen Compilerfehler wie ausgeben error: call to non-'constexpr' function 'void __assert_fail(const char*, const char*, unsigned int, const char*)'.

Dies funktioniert für mich bei den meisten Compilern: https://godbolt.org/z/4nT2ub

template<int Size>
struct Array {
  int m_vals[Size];
  constexpr const int& getElement(int idx) const
  {
    assert(idx < Size);
    return m_vals[idx];
  }
};

Jetzt static_assertist veraltet, da constexpres kein undefiniertes Verhalten enthalten kann. Wenn Sie also den Array-Index-Compiler sprengen, meldet er den richtigen Fehler. Siehe hier .

Problem ist assert. Es ist ein Makro, dessen Implementierung nicht definiert ist. Wenn der Compiler eine Funktion verwendet, die keine ist, schlägt constexprsie fehl, aber wie Sie sehen können, haben 3 große Compiler damit kein Problem.

c ++ 11 kann nicht so sein. Entweder idxkonstant oder nein
wäre schön, wenn jeweils eine Funktion vorhanden wäre.
Es könnte so sein, wenn eine Funktion erzwungen wird

template<int Size>
struct Array {
    int m_vals[Size];
    constexpr const  int& getElement( int idx ) const       
    {
    if constexpr(is_same_v<decltype(idx), const int>)
        static_assert( idx < Size, "out-of-bounds" ); // a no-go for non-constexpr calls
    else 
        assert( idx < Size ); // a no-go for constexpr funcs in c++11

    return m_vals[idx];
    }
};

int main() {                // E.g. up to next //

        Array<7> M;  
        int i=M.getElement(1);
}                           //