Warum benötigen wir Anforderungen erfordert?

Eine der Ecken von C ++ 20-Konzepten ist, dass es bestimmte Situationen gibt, in denen Sie schreiben müssen requires requires. Zum Beispiel dieses Beispiel aus [expr.prim.req] / 3 :

Ein Requires-Ausdruck kann auch in einer Requires-Klausel ([temp]) verwendet werden, um Ad-hoc-Einschränkungen für Vorlagenargumente wie das folgende zu schreiben:

template<typename T>
  requires requires (T x) { x + x; }
    T add(T a, T b) { return a + b; }

Das erste erfordert die Einführung der require-Klausel und das zweite die Einführung des require-Ausdrucks .

Was ist der technische Grund für die Notwendigkeit dieses zweiten requiresSchlüsselworts? Warum können wir nicht einfach schreiben lassen:

template<typename T>
  requires (T x) { x + x; }
    T add(T a, T b) { return a + b; }

_{(Hinweis: Bitte antworten Sie nicht auf die Grammatik requires)}

Es ist, weil die Grammatik es erfordert. Es tut.

Eine requiresEinschränkung nicht haben einen verwenden requiresAusdruck. Es kann jeden mehr oder weniger willkürlichen booleschen konstanten Ausdruck verwenden. Daher requires (foo)muss eine legitime requiresEinschränkung sein.

Ein requires Ausdruck (das Ding, das prüft, ob bestimmte Dinge bestimmten Einschränkungen folgen) ist ein bestimmtes Konstrukt; Es wird nur mit demselben Schlüsselwort eingeführt. requires (foo f)wäre der Anfang eines gültigen requiresAusdrucks.

Was Sie wollen, ist, dass Sie, wenn Sie requiresan einem Ort verwenden, der Einschränkungen akzeptiert, in der Lage sein sollten, aus der requiresKlausel einen "Constraint + Ausdruck" zu machen .

Hier ist also die Frage: Wenn Sie an requires (foo)einen Ort setzen, der für eine erforderliche Einschränkung geeignet ist ... wie weit muss der Parser gehen, bevor er erkennen kann, dass dies eine erforderliche Einschränkung ist und nicht eine Einschränkung + Ausdruck, wie Sie es möchten sein?

Bedenken Sie:

void bar() requires (foo)
{
  //stuff
}

Wenn fooes sich um einen Typ handelt, (foo)handelt es sich um eine Parameterliste eines erforderlichen Ausdrucks, und alles in {}ist nicht der Hauptteil der Funktion, sondern der Hauptteil dieses requiresAusdrucks. Andernfalls fooist ein Ausdruck in einer requiresKlausel.

Nun, man könnte sagen, dass der Compiler nur herausfinden sollte, was foozuerst kommt. Aber C ++ mag es wirklich nicht, wenn der Compiler beim Parsen einer Folge von Token herausfinden muss, was diese Bezeichner bedeuten, bevor er einen Sinn für die Token ergibt. Ja, C ++ ist kontextsensitiv, dies geschieht also. Der Ausschuss zieht es jedoch vor, dies nach Möglichkeit zu vermeiden.

Also ja, es ist Grammatik.

Die Situation ist genau analog zu noexcept(noexcept(...)). Sicher, das klingt eher nach einer schlechten als nach einer guten Sache, aber lassen Sie mich das erklären. :) Wir beginnen mit dem, was Sie bereits wissen:

C ++ 11 hat " noexcept-clauses" und "-expressions" noexcept. Sie machen verschiedene Dinge.

• Eine noexceptKlausel sagt: "Diese Funktion sollte nicht außer ... (eine Bedingung) sein." Es geht auf eine Funktionsdeklaration, nimmt einen booleschen Parameter und verursacht eine Verhaltensänderung in der deklarierten Funktion.

• Ein Ausdruck noexceptsagt: "Compiler, bitte sagen Sie mir, ob (irgendein Ausdruck) keine Ausnahme ist." Es ist selbst ein boolescher Ausdruck. Es hat keine "Nebenwirkungen" auf das Verhalten des Programms - es fragt nur den Compiler nach der Antwort auf eine Ja / Nein-Frage. "Ist dieser Ausdruck keine Ausnahme?"

Wir können Nest einen noexcept-Ausdrucks in einem noexcept-Klausel, aber wir es in der Regel schlechten Stil betrachten , dies zu tun.

template<class T>
void incr(T t) noexcept(noexcept(++t));  // NOT SO HOT

Es wird als besserer Stil angesehen, den noexceptAusdruck in ein Typmerkmal zu kapseln .

template<class T> inline constexpr bool is_nothrow_incrable_v =
    noexcept(++std::declval<T&>());  // BETTER, PART 1

template<class T>
void incr(T t) noexcept(is_nothrow_incrable_v<T>);  // BETTER, PART 2

Der C ++ 2a Working Draft enthält " requires-clauses" und "-expressions" requires. Sie machen verschiedene Dinge.

• Eine requiresKlausel besagt: "Diese Funktion sollte an der Überlastungsauflösung teilnehmen, wenn ... (eine Bedingung)." Es geht auf eine Funktionsdeklaration, nimmt einen booleschen Parameter und verursacht eine Verhaltensänderung in der deklarierten Funktion.

• Ein requiresAusdruck sagt: "Compiler, bitte sagen Sie mir, ob (einige Ausdrücke) wohlgeformt sind." Es ist selbst ein boolescher Ausdruck. Es hat keine "Nebenwirkungen" auf das Verhalten des Programms - es fragt nur den Compiler nach der Antwort auf eine Ja / Nein-Frage. "Ist dieser Ausdruck wohlgeformt?"

Wir können Nest einen requires-Ausdrucks in einem requires-Klausel, aber wir es in der Regel schlechten Stil betrachten , dies zu tun.

template<class T>
void incr(T t) requires (requires(T t) { ++t; });  // NOT SO HOT

Es wird als besserer Stil angesehen, den requiresAusdruck in ein Typmerkmal zu kapseln ...

template<class T> inline constexpr bool is_incrable_v =
    requires(T t) { ++t; };  // BETTER, PART 1

template<class T>
void incr(T t) requires is_incrable_v<T>;  // BETTER, PART 2

... oder in einem (C ++ 2a Working Draft) Konzept.

template<class T> concept Incrable =
    requires(T t) { ++t; };  // BETTER, PART 1

template<class T>
void incr(T t) requires Incrable<T>;  // BETTER, PART 2

Ich denke, die Konzeptseite von cppreference erklärt dies. Ich kann sozusagen mit "Mathe" erklären, warum das so sein muss:

Wenn Sie ein Konzept definieren möchten, gehen Sie folgendermaßen vor:

template<typename T>
concept Addable = requires (T x) { x + x; }; // requires-expression

Wenn Sie eine Funktion deklarieren möchten, die dieses Konzept verwendet, gehen Sie folgendermaßen vor:

template<typename T> requires Addable<T> // requires-clause, not requires-expression
T add(T a, T b) { return a + b; }

Wenn Sie das Konzept nicht separat definieren möchten, müssen Sie wahrscheinlich nur eine Substitution durchführen. Nehmen Sie dieses Teil requires (T x) { x + x; };und ersetzen Sie das Addable<T>Teil, und Sie erhalten:

template<typename T> requires requires (T x) { x + x; }
T add(T a, T b) { return a + b; }

Nach was fragst du?

Ich fand einen Kommentar von Andrew Sutton (einem der Concepts-Autoren, der ihn in gcc implementiert hat) in dieser Hinsicht sehr hilfreich, daher dachte ich, ich würde ihn hier fast vollständig zitieren:

Vor nicht allzu langer Zeit waren Anforderungsausdrücke (der durch den zweiten eingeführte Ausdruck erfordert) in Einschränkungsausdrücken (der durch den ersten eingeführte Ausdruck erfordert) nicht zulässig. Es konnte nur in Konzeptdefinitionen erscheinen. Genau dies wird in dem Abschnitt dieses Papiers vorgeschlagen, in dem diese Behauptung erscheint.

Im Jahr 2016 gab es jedoch einen Vorschlag, diese Einschränkung zu lockern [Anmerkung des Herausgebers: P0266 ]. Beachten Sie den durchgestrichenen Absatz 4 in Abschnitt 4 des Papiers. Und so wurde geboren erfordert erfordert.

Um die Wahrheit zu sagen, ich hatte diese Einschränkung nie in GCC implementiert, also war es immer möglich gewesen. Ich denke, dass Walter das entdeckt und nützlich gefunden hat, was zu diesem Papier geführt hat.

Damit niemand glaubt, dass ich nicht empfindlich auf das Schreiben reagiere, habe ich einige Zeit damit verbracht, herauszufinden, ob dies vereinfacht werden kann. Kurze Antwort: nein.

Das Problem ist, dass nach einer Vorlagenparameterliste zwei grammatikalische Konstrukte eingeführt werden müssen: sehr häufig ein Einschränkungsausdruck (wie P && Q) und gelegentlich syntaktische Anforderungen (wie requires (T a) { ... }). Das nennt man einen Anforderungsausdruck.

Das erste erfordert die Einführung der Einschränkung. Die zweite Anforderung führt den erforderlichen Ausdruck ein. So komponiert die Grammatik. Ich finde es überhaupt nicht verwirrend.

Ich habe einmal versucht, diese auf eine einzige Anforderung zu reduzieren. Leider führt dies zu einigen ernsthaft schwierigen Analyseproblemen. Sie können beispielsweise nicht leicht erkennen, ob a (after the require einen verschachtelten Unterausdruck oder eine Parameterliste bezeichnet. Ich glaube nicht, dass es eine perfekte Disambiguierung dieser Syntax gibt (siehe die Begründung für eine einheitliche Initialisierungssyntax; dieses Problem gibt es auch).

Sie treffen also eine Wahl: make erfordert die Einführung eines Ausdrucks (wie jetzt) ​​oder die Einführung einer parametrisierten Liste von Anforderungen.

Ich habe mich für den aktuellen Ansatz entschieden, weil ich die meiste Zeit (wie in fast 100% der Fälle) etwas anderes als einen erforderlichen Ausdruck möchte. Und in dem äußerst seltenen Fall, dass ich einen Anforderungsausdruck für Ad-hoc-Einschränkungen wollte, macht es mir wirklich nichts aus, das Wort zweimal zu schreiben. Es ist ein offensichtlicher Indikator dafür, dass ich keine ausreichend solide Abstraktion für die Vorlage entwickelt habe. (Denn wenn ich es hätte, hätte es einen Namen.)

Ich hätte mich dafür entscheiden können, dass die Anforderungen einen Anforderungen-Ausdruck einführen. Das ist tatsächlich schlimmer, weil praktisch alle Ihre Einschränkungen so aussehen würden:

template<typename T>
  requires { requires Eq<T>; }
void f(T a, T b);

Hier wird die zweite Anforderung als verschachtelte Anforderung bezeichnet. es wertet seinen Ausdruck aus (anderer Code im Block des erforderlichen Ausdrucks wird nicht ausgewertet). Ich denke, das ist viel schlimmer als der Status Quo. Jetzt müssen Sie zweimal überall schreiben.

Ich hätte auch mehr Schlüsselwörter verwenden können. Dies ist ein eigenständiges Problem - und es ist nicht nur ein Fahrradschuppen. Es könnte eine Möglichkeit geben, Schlüsselwörter "neu zu verteilen", um die Duplizierung zu vermeiden, aber ich habe nicht ernsthaft darüber nachgedacht. Aber das ändert nichts an der Essenz des Problems.

Weil Sie sagen, dass eine Sache A eine Anforderung B hat und die Anforderung B eine Anforderung C.

Das Ding A benötigt B, was wiederum C erfordert.

Die "require" -Klausel selbst erfordert etwas.

Sie haben Ding A (erfordert B (erfordert C)).

Meh. :) :)