Warum lässt ein if constexpr diesen Kernfehler des konstanten Ausdrucks nicht verschwinden?

In Bezug auf diese Frage. Der Kernkonstantenausdruck, der zum Initialisieren von verwendet wird constexpr Variable y ist schlecht geformt. So viel ist gegeben.

Aber wenn ich versuche, den zu drehen if In ein if constexpr:

template <typename T>
void foo() {
    constexpr int x = -1;
    if constexpr (x >= 0){
        constexpr int y = 1 << x;
    }
}

int main(){
    foo<int>();
}

Der Fehler bleibt bestehen. Mit GCC 7.2 gibt es immer noch:

error: right operand of shift expression '(1 << -1)' is negative [-fpermissive]

Aber ich dachte, dass die semantische Prüfung auf einem verworfenen Zweig unvorgeformt bleiben sollte.

Einen Umweg über a machen constexpr Lambda hilft aber:

template <typename T>
void foo(){
    constexpr int x = -1;
    constexpr auto p = []() constexpr { return x; };
    if constexpr (x >= 0){
        constexpr int y = 1<<p();
    }
}

Der constexpr Spezifizierer an y scheint zu ändern, wie der verworfene Zweig überprüft wird. Ist dies das beabsichtigte Verhalten?

@max66 war so freundlich, andere Implementierungen zu überprüfen. Er berichtet, dass der Fehler sowohl mit GCC (7.2.0 / Head 8.0.0) als auch mit Clang (5.0.0 / Head 6.0.0) reproduzierbar sei.

Der Standard sagt nicht viel darüber aus verworfene Aussage eines if constexpr. Es gibt im Wesentlichen zwei Aussagen in [stmt.if] über diese:

1. In einer einschließenden Vorlage werden verworfene Anweisungen nicht instanziiert.
2. Namen, auf die von einer verworfenen Anweisung verwiesen wird, müssen nicht ODR definiert werden.

Beides trifft auf Ihre Verwendung nicht zu: Die Compiler beschweren sich zu Recht darüber constexpr wenn Initialisierung. Beachten Sie, dass Sie die Bedingung von einem Vorlagenparameter abhängig machen müssen, wenn Sie die nutzen möchten Instanziierung fehlschlagen: Wenn der Wert nicht von einem Vorlagenparameter abhängig ist, tritt der Fehler auf, wenn die Vorlage es ist definiert. Dieser Code schlägt beispielsweise immer noch fehl:

template <typename T>
void f() {
    constexpr int x = -1;
    if constexpr (x >= 0){
        constexpr int y = 1<<x;
    }
}

Allerdings, wenn Sie machen x abhängig vom Typ T es ist in Ordnung, auch wenn f wird mit instanziiert int:

template <typename T>
void f() {
    constexpr T x = -1;
    if constexpr (x >= 0){
        constexpr int y = 1<<x;
    }
}
int main() {
    f<int>();
}

Beachten Sie dies für die Anweisung, die von verworfen wird Konstexpr Wenn:

Die verworfene Anweisung kann nicht für jede mögliche Spezialisierung falsch geformt sein:

Um das Problem zu beheben, können Sie die Anweisung abhängig vom Vorlagenparameter machen, z

template<typename T, int X> struct dependent_value { constexpr static int V = X; };

template <typename T>
void foo() {
    constexpr int x = -1;
    if constexpr (x >= 0){
        constexpr int y = 1 << dependent_value<T, x>::V;
    }
}

LIVE

Ich bin mir nicht sicher, warum Sie erwarten, dass der Zweig nicht überprüft wird. Das einzige Mal, wenn ein if-Zweig “nicht überprüft” wird, ist, wenn er Teil einer Vorlage ist und nicht instantiiert, gem [stmt.if]p2:

Wenn die Bedingung nach ihrer Instanziierung nicht wertabhängig ist, wird die verworfene Unteranweisung (falls vorhanden) während der Instanziierung einer einschließenden Vorlagenentität (Klausel 17) nicht instanziiert.

Ihr Code scheint sich nicht in einer Situation zu befinden, in der dies zutrifft.