Berechnen der Länge eines C-Strings zur Kompilierungszeit. Ist das wirklich ein constexpr?

Ich versuche, die Länge eines String-Literals zur Kompilierungszeit zu berechnen. Dazu verwende ich folgenden Code:

#include <cstdio>

int constexpr length(const char* str)
{
    return *str ? 1 + length(str + 1) : 0;
}

int main()
{
    printf("%d %d", length("abcd"), length("abcdefgh"));
}

Alles funktioniert wie erwartet, das Programm druckt 4 und 8. Der durch clang generierte Assembler-Code zeigt, dass die Ergebnisse zur Kompilierungszeit berechnet werden:

0x100000f5e:  leaq   0x35(%rip), %rdi          ; "%d %d"
0x100000f65:  movl   $0x4, %esi
0x100000f6a:  movl   $0x8, %edx
0x100000f6f:  xorl   %eax, %eax
0x100000f71:  callq  0x100000f7a               ; symbol stub for: printf

Meine Frage: lengthWird durch den Standard garantiert, dass die Kompilierungszeit der Funktion ausgewertet wird?

Wenn dies zutrifft, hat sich mir gerade die Tür für Berechnungen von Zeichenfolgenliteralen zur Kompilierungszeit geöffnet ... zum Beispiel kann ich Hashes zur Kompilierungszeit berechnen und vieles mehr ...

Konstante Ausdrücke sind nicht garantiert bei der Kompilierung ausgewertet werden, haben wir nur ein nicht-normatives Zitat aus Entwurf C ++ Standard Abschnitt 5.19 Konstante Ausdrücke , der dies sagt aber:

[...]> [Hinweis: Konstante Ausdrücke können während der Übersetzung ausgewertet werden. - Endnote]

Sie können das Ergebnis einer constexprVariablen zuweisen , um sicherzustellen, dass es zur Kompilierungszeit ausgewertet wird. Dies geht aus der C ++ 11-Referenz von Bjarne Stroustrup hervor, in der es heißt ( Hervorhebung von mir ):

Um Ausdrücke zur Kompilierungszeit auswerten zu können, möchten wir auch verlangen , dass Ausdrücke zur Kompilierungszeit ausgewertet werden. constexpr vor einer Variablendefinition macht das (und impliziert const):

Beispielsweise:

constexpr int len1 = length("abcd") ;

Bjarne Stroustrup gibt in diesem isocpp-Blogeintrag eine Zusammenfassung darüber, wann wir die Bewertung der Kompilierungszeit sicherstellen können, und sagt:

[...] Die richtige Antwort - wie von Herb angegeben - ist, dass eine constexpr-Funktion gemäß dem Standard zur Compiler- oder Laufzeit ausgewertet werden kann, sofern sie nicht als konstanter Ausdruck verwendet wird. In diesem Fall muss sie beim Kompilieren ausgewertet werden -Zeit. Um eine Auswertung zur Kompilierungszeit zu gewährleisten, müssen wir sie entweder verwenden, wenn ein konstanter Ausdruck erforderlich ist (z. B. als Array-Bindung oder als Fallbezeichnung), oder sie zum Initialisieren eines Constexpr verwenden. Ich würde hoffen, dass kein Compiler mit Selbstachtung die Optimierungsmöglichkeit verpasst, um das zu tun, was ich ursprünglich gesagt habe: "Eine constexpr-Funktion wird zur Kompilierungszeit ausgewertet, wenn alle ihre Argumente konstante Ausdrücke sind."

Dies beschreibt also zwei Fälle, in denen es zur Kompilierungszeit ausgewertet werden sollte:

1. Verwenden Sie es, wenn ein konstanter Ausdruck erforderlich ist. Dies scheint an einer beliebigen Stelle im Standardentwurf zu sein, an der die Phrase shall be ... converted constant expressionoder shall be ... constant expressionverwendet wird, z. B. an ein gebundenes Array.
2. Verwenden Sie es, um a constexprwie oben beschrieben zu initialisieren .

Es ist wirklich einfach herauszufinden, ob ein Aufruf einer constexprFunktion zu einem konstanten Kernausdruck führt oder lediglich optimiert wird:

Verwenden Sie es in einem Kontext, in dem ein konstanter Ausdruck erforderlich ist.

int main()
{
    constexpr int test_const = length("abcd");
    std::array<char,length("abcdefgh")> test_const2;
}

Nur eine Anmerkung, die moderne Compiler (wie gcc-4.x) strlenzur Kompilierungszeit für String-Literale verwenden, da sie normalerweise als intrinsische Funktion definiert sind . Ohne aktivierte Optimierungen. Obwohl das Ergebnis keine Kompilierungszeitkonstante ist.

Z.B:

printf("%zu\n", strlen("abc"));

Ergebnisse in:

movl    $3, %esi    # strlen("abc")
movl    $.LC0, %edi # "%zu\n"
movl    $0, %eax
call    printf

Lassen Sie mich eine andere Funktion vorschlagen, die die Länge eines Strings zur Kompilierungszeit berechnet, ohne rekursiv zu sein.

template< size_t N >
constexpr size_t length( char const (&)[N] )
{
  return N-1;
}

Schauen Sie sich diesen Beispielcode bei ideone an .

Es gibt keine Garantie dafür, dass eine constexprFunktion zur Kompilierungszeit ausgewertet wird, obwohl jeder vernünftige Compiler dies bei entsprechenden aktivierten Optimierungsstufen tut. Auf der anderen Seite, Template - Parameter müssen zur Compile-Zeit ausgewertet werden.

Ich habe den folgenden Trick verwendet, um die Auswertung zur Kompilierungszeit zu erzwingen. Leider funktioniert es nur mit Integralwerten (dh nicht mit Gleitkommawerten).

template<typename T, T V>
struct static_eval
{
  static constexpr T value = V;
};

Nun, wenn Sie schreiben

if (static_eval<int, length("hello, world")>::value > 7) { ... }

Sie können sicher sein, dass die ifAnweisung eine Konstante zur Kompilierungszeit ohne Laufzeitaufwand ist.

Eine kurze Erklärung aus dem Wikipedia-Eintrag zu verallgemeinerten konstanten Ausdrücken :

Die Verwendung von constexpr für eine Funktion führt zu Einschränkungen bei der Funktionsweise dieser Funktion. Erstens muss die Funktion einen nicht ungültigen Rückgabetyp haben. Zweitens kann der Funktionskörper keine Variablen deklarieren oder neue Typen definieren. Drittens darf der Body nur Deklarationen, Null-Anweisungen und eine einzelne return-Anweisung enthalten. Es müssen Argumentwerte vorhanden sein, sodass der Ausdruck in der return-Anweisung nach der Argumentersetzung einen konstanten Ausdruck erzeugt.

Wenn das constexprSchlüsselwort vor einer Funktionsdefinition steht, wird der Compiler angewiesen, zu überprüfen, ob diese Einschränkungen erfüllt sind. Wenn ja und die Funktion mit einer Konstanten aufgerufen wird, ist der zurückgegebene Wert garantiert konstant und kann daher überall dort verwendet werden, wo ein konstanter Ausdruck erforderlich ist.