Calcolo della lunghezza di una stringa C in fase di compilazione. È davvero un constexpr?

Sto cercando di calcolare la lunghezza di una stringa letterale in fase di compilazione. Per farlo sto usando il seguente codice:

#include <cstdio>

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

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

Tutto funziona come previsto, il programma stampa 4 e 8. Il codice assembly generato da clang mostra che i risultati vengono calcolati in fase di compilazione:

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

La mia domanda: è garantito dallo standard che la lengthfunzione verrà valutata in fase di compilazione?

Se questo è vero, la porta per i calcoli dei valori letterali delle stringhe in fase di compilazione si è appena aperta per me ... per esempio posso calcolare gli hash in fase di compilazione e molti altri ...

Non è garantito che le espressioni costanti vengano valutate in fase di compilazione, abbiamo solo una citazione non normativa dalla bozza della sezione standard C ++ 5.19 Espressioni costanti che dice questo però:

[...]> [Nota: le espressioni costanti possono essere valutate durante la traduzione. - nota finale]

Puoi assegnare il risultato alla constexprvariabile per assicurarti che venga valutato in fase di compilazione, possiamo vederlo dal riferimento C ++ 11 di Bjarne Stroustrup che dice ( enfasi mia ):

Oltre ad essere in grado di valutare le espressioni in fase di compilazione, vogliamo essere in grado di richiedere che le espressioni vengano valutate in fase di compilazione; constexpr davanti a una definizione di variabile fa questo (e implica const):

Per esempio:

constexpr int len1 = length("abcd") ;

Bjarne Stroustrup fornisce un riepilogo di quando possiamo garantire la valutazione del tempo di compilazione in questo post del blog isocpp e dice:

[...] La risposta corretta - come affermato da Herb - è che secondo lo standard una funzione constexpr può essere valutata in fase di compilazione o in fase di esecuzione a meno che non sia usata come espressione costante, nel qual caso deve essere valutata in fase di compilazione -tempo. Per garantire la valutazione in fase di compilazione, dobbiamo usarlo dove è richiesta un'espressione costante (ad esempio, come un array associato o come un'etichetta case) o usarlo per inizializzare un constexpr. Mi auguro che nessun compilatore che si rispetti perda l'opportunità di ottimizzazione di fare quello che ho detto inizialmente: "Una funzione constexpr viene valutata in fase di compilazione se tutti i suoi argomenti sono espressioni costanti".

Quindi questo delinea due casi in cui dovrebbe essere valutato in fase di compilazione:

1. Usalo dove è richiesta un'espressione costante, questo sembrerebbe essere ovunque nella bozza di standard in cui viene utilizzata la frase shall be ... converted constant expressiono shall be ... constant expression, ad esempio un limite di matrice.
2. Usalo per inizializzare un constexprcome ho delineato sopra.

È davvero facile scoprire se una chiamata a una constexprfunzione si traduce in un'espressione costante di base o viene semplicemente ottimizzata:

Usalo in un contesto in cui è richiesta un'espressione costante.

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

Solo una nota, che i compilatori moderni (come gcc-4.x) fanno strlenper i valori letterali di stringa in fase di compilazione perché normalmente sono definiti come una funzione intrinseca . Senza ottimizzazioni abilitate. Sebbene il risultato non sia una costante del tempo di compilazione.

Per esempio:

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

Risultati in:

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

Vorrei proporre un'altra funzione che calcola la lunghezza di una stringa in fase di compilazione senza essere ricorsiva.

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

Dai un'occhiata a questo codice di esempio su ideone .

Non vi è alcuna garanzia che una constexprfunzione venga valutata in fase di compilazione, sebbene qualsiasi compilatore ragionevole lo farà a livelli di ottimizzazione appropriati abilitati. D'altra parte, i parametri del modello devono essere valutati in fase di compilazione.

Ho usato il seguente trucco per forzare la valutazione in fase di compilazione. Purtroppo funziona solo con valori integrali (cioè non con valori in virgola mobile).

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

Ora, se scrivi

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

puoi essere certo che l' ifistruzione è una costante in fase di compilazione senza overhead di runtime.

Una breve spiegazione dalla voce di Wikipedia sulle espressioni costanti generalizzate :

L'uso di constexpr su una funzione impone alcune limitazioni su ciò che quella funzione può fare. Innanzitutto, la funzione deve avere un tipo di ritorno non void. In secondo luogo, il corpo della funzione non può dichiarare variabili o definire nuovi tipi. Terzo, il corpo può contenere solo dichiarazioni, istruzioni null e una singola istruzione return. Devono esistere valori di argomento tali che, dopo la sostituzione dell'argomento, l'espressione nell'istruzione return produca un'espressione costante.

La presenza della constexprparola chiave prima di una definizione di funzione indica al compilatore di verificare se queste limitazioni sono soddisfatte. Se sì, e la funzione viene chiamata con una costante, il valore restituito è garantito come costante e quindi può essere utilizzato ovunque sia richiesta un'espressione costante.