Calcul de la longueur d'une chaîne C au moment de la compilation. Est-ce vraiment un constexpr?

J'essaie de calculer la longueur d'une chaîne littérale au moment de la compilation. Pour ce faire, j'utilise le code suivant:

#include <cstdio>

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

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

Tout fonctionne comme prévu, le programme imprime 4 et 8. Le code assembleur généré par clang montre que les résultats sont calculés au moment de la compilation:

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

Ma question: est-il garanti par la norme que la lengthfonction sera évaluée lors de la compilation?

Si cela est vrai, la porte pour les calculs de littéraux de chaîne au moment de la compilation vient de s'ouvrir pour moi ... par exemple, je peux calculer des hachages au moment de la compilation et bien d'autres ...

Les expressions constantes ne sont pas garanties pour être évaluées au moment de la compilation, nous n'avons qu'une citation non normative du projet de section standard C ++ 5.19 Expressions constantes qui dit ceci:

[...]> [Remarque: Les expressions constantes peuvent être évaluées pendant la traduction. — note de fin]

Vous pouvez affecter le résultat à une constexprvariable pour être sûr qu'il est évalué au moment de la compilation, nous pouvons le voir à partir de la référence C ++ 11 de Bjarne Stroustrup qui dit (c'est moi qui souligne ):

En plus de pouvoir évaluer les expressions au moment de la compilation, nous voulons être en mesure d' exiger que les expressions soient évaluées au moment de la compilation; constexpr devant une définition de variable fait cela (et implique const):

Par exemple:

constexpr int len1 = length("abcd") ;

Bjarne Stroustrup donne un résumé du moment où nous pouvons assurer l'évaluation du temps de compilation dans cette entrée de blog isocpp et dit:

[...] La bonne réponse - comme indiqué par Herb - est que selon la norme une fonction constexpr peut être évaluée au moment du compilateur ou à l'exécution à moins qu'elle ne soit utilisée comme une expression constante, auquel cas elle doit être évaluée à la compilation -temps. Pour garantir l'évaluation au moment de la compilation, nous devons soit l'utiliser là où une expression constante est requise (par exemple, en tant que tableau lié ou en tant qu'étiquette de cas) ou l'utiliser pour initialiser une constexpr. J'espère qu'aucun compilateur qui se respecte ne manquerait l'opportunité d'optimisation de faire ce que j'ai dit à l'origine: "Une fonction constexpr est évaluée au moment de la compilation si tous ses arguments sont des expressions constantes."

Donc, cela décrit deux cas où il devrait être évalué au moment de la compilation:

1. Utilisez-le là où une expression constante est requise, cela semblerait être n'importe où dans le projet de norme où la phrase shall be ... converted constant expressionou shall be ... constant expressionest utilisée, comme un tableau lié.
2. Utilisez-le pour initialiser un constexprcomme je l'ai décrit ci-dessus.

Il est vraiment facile de savoir si un appel à une constexprfonction aboutit à une expression constante de base ou s'il est simplement optimisé:

Utilisez-le dans un contexte où une expression constante est requise.

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

Juste une note, que les compilateurs modernes (comme gcc-4.x) le font strlenpour les chaînes littérales au moment de la compilation car il est normalement défini comme une fonction intrinsèque . Sans optimisations activées. Bien que le résultat ne soit pas une constante de temps de compilation.

Par exemple:

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

Résulte en:

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

Permettez-moi de proposer une autre fonction qui calcule la longueur d'une chaîne au moment de la compilation sans être récursive.

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

Jetez un œil à cet exemple de code sur ideone .

Il n'y a aucune garantie qu'une constexprfonction est évaluée au moment de la compilation, bien que tout compilateur raisonnable le fasse aux niveaux d'optimisation appropriés activés. D'un autre côté, les paramètres du modèle doivent être évalués au moment de la compilation.

J'ai utilisé l'astuce suivante pour forcer l'évaluation au moment de la compilation. Malheureusement, cela ne fonctionne qu'avec des valeurs intégrales (c'est-à-dire pas avec des valeurs à virgule flottante).

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

Maintenant, si tu écris

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

vous pouvez être sûr que l' ifinstruction est une constante de compilation sans surcharge au moment de l'exécution.

Une brève explication de l'entrée de Wikipédia sur les expressions constantes généralisées :

L'utilisation de constexpr sur une fonction impose certaines limitations à ce que cette fonction peut faire. Tout d'abord, la fonction doit avoir un type de retour non void. Deuxièmement, le corps de la fonction ne peut pas déclarer de variables ou définir de nouveaux types. Troisièmement, le corps ne peut contenir que des déclarations, des instructions nulles et une seule instruction return. Il doit exister des valeurs d'argument telles que, après la substitution d'argument, l'expression dans l'instruction de retour produise une expression constante.

Le fait d'avoir le constexprmot - clé avant une définition de fonction indique au compilateur de vérifier si ces limitations sont respectées. Si oui et que la fonction est appelée avec une constante, la valeur renvoyée est garantie constante et peut donc être utilisée partout où une expression constante est requise.