Compilar o comprimento de uma string C em tempo de compilação. Este é realmente um constexpr?

Estou tentando calcular o comprimento de uma string literal em tempo de compilação. Para fazer isso, estou usando o seguinte código:

#include <cstdio>

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

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

Tudo funciona conforme o esperado, o programa imprime 4 e 8. O código de montagem gerado pelo clang mostra que os resultados são calculados em tempo de compilação:

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

Minha pergunta: é garantido pelo padrão que a lengthfunção será avaliada em tempo de compilação?

Se isso for verdade, a porta para cálculos de literais de string em tempo de compilação acabou de se abrir para mim ... por exemplo, posso calcular hashes em tempo de compilação e muito mais ...

Expressões constantes não são garantidas para serem avaliadas em tempo de compilação, nós temos apenas uma citação não normativa do rascunho da seção padrão C ++ 5.19 Expressões constantes que diz o seguinte:

[...]> [Nota: As expressões constantes podem ser avaliadas durante a tradução. — nota final]

Você pode atribuir o resultado à constexprvariável para ter certeza de que ele é avaliado em tempo de compilação, podemos ver isso na referência C ++ 11 de Bjarne Stroustrup que diz ( grifo meu ):

Além de poder avaliar expressões em tempo de compilação, queremos ser capazes de exigir que as expressões sejam avaliadas em tempo de compilação; constexpr na frente de uma definição de variável faz isso (e implica const):

Por exemplo:

constexpr int len1 = length("abcd") ;

Bjarne Stroustrup fornece um resumo de quando podemos garantir a avaliação do tempo de compilação nesta entrada do blog isocpp e diz:

[...] A resposta correta - como afirma Herb - é que de acordo com o padrão uma função constexpr pode ser avaliada em tempo de compilação ou tempo de execução a menos que seja usada como uma expressão constante, caso em que deve ser avaliada em tempo de compilação -Tempo. Para garantir a avaliação em tempo de compilação, devemos usá-lo onde uma expressão constante é necessária (por exemplo, como um limite de array ou como um rótulo de caso) ou usá-lo para inicializar um constexpr. Espero que nenhum compilador que se preze perca a oportunidade de otimização de fazer o que eu disse originalmente: "Uma função constexpr é avaliada em tempo de compilação se todos os seus argumentos forem expressões constantes."

Portanto, isso descreve dois casos em que deve ser avaliado em tempo de compilação:

1. Use-o onde uma expressão constante é necessária, parece estar em qualquer lugar no padrão de rascunho onde a frase shall be ... converted constant expressionou shall be ... constant expressioné usada, como um limite de matriz.
2. Use-o para inicializar um constexprconforme delineado acima.

É realmente fácil descobrir se uma chamada para uma constexprfunção resulta em uma expressão constante central ou se está apenas sendo otimizada:

Use-o em um contexto onde uma expressão constante é necessária.

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

Apenas uma observação, que compiladores modernos (como gcc-4.x) fazem strlenpara literais de string em tempo de compilação porque normalmente é definido como uma função intrínseca . Sem otimizações habilitadas. Embora o resultado não seja uma constante de tempo de compilação.

Por exemplo:

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

Resulta em:

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

Deixe-me propor outra função que calcula o comprimento de uma string em tempo de compilação sem ser recursiva.

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

Dê uma olhada neste código de amostra em ideone .

Não há garantia de que uma constexprfunção seja avaliada em tempo de compilação, embora qualquer compilador razoável o faça nos níveis de otimização apropriados habilitados. Por outro lado, os parâmetros do template devem ser avaliados em tempo de compilação.

Usei o seguinte truque para forçar a avaliação em tempo de compilação. Infelizmente, ele só funciona com valores integrais (ou seja, não com valores de ponto flutuante).

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

Agora, se você escrever

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

você pode ter certeza de que a ifinstrução é uma constante de tempo de compilação sem sobrecarga de tempo de execução.

Uma breve explicação da entrada da Wikipedia sobre Expressões constantes generalizadas :

O uso de constexpr em uma função impõe algumas limitações sobre o que essa função pode fazer. Primeiro, a função deve ter um tipo de retorno não nulo. Em segundo lugar, o corpo da função não pode declarar variáveis ​​ou definir novos tipos. Terceiro, o corpo pode conter apenas declarações, instruções nulas e uma única instrução de retorno. Deve haver valores de argumento de forma que, após a substituição do argumento, a expressão na instrução de retorno produza uma expressão constante.

Ter a constexprpalavra - chave antes de uma definição de função instrui o compilador a verificar se essas limitações são atendidas. Se sim, e a função é chamada com uma constante, o valor retornado é garantido como constante e, portanto, pode ser usado em qualquer lugar em que uma expressão constante seja necessária.