Menghitung panjang string C pada waktu kompilasi. Apakah ini benar-benar sebuah constexpr?

Saya mencoba menghitung panjang string literal pada waktu kompilasi. Untuk melakukannya, saya menggunakan kode berikut:

#include <cstdio>

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

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

Semuanya bekerja seperti yang diharapkan, program mencetak 4 dan 8. Kode assembly yang dihasilkan oleh clang menunjukkan bahwa hasil dihitung pada waktu kompilasi:

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

Pertanyaan saya: apakah dijamin oleh standar bahwa lengthfungsi akan dievaluasi waktu kompilasi?

Jika ini benar, pintu untuk komputasi literal string waktu kompilasi baru saja dibuka untuk saya ... misalnya saya dapat menghitung hash pada waktu kompilasi dan banyak lagi ...

Ekspresi konstan tidak dijamin akan dievaluasi pada waktu kompilasi, kami hanya memiliki kutipan non-normatif dari draf bagian standar C ++ 5.19 Ekspresi konstan yang mengatakan ini:

[...]> [Catatan: Ekspresi konstan dapat dievaluasi selama penerjemahan. — catatan akhir]

Anda dapat menetapkan hasilnya ke constexprvariabel untuk memastikannya dievaluasi pada waktu kompilasi, kita dapat melihat ini dari referensi C ++ 11 Bjarne Stroustrup yang mengatakan ( penekanan saya ):

Selain dapat mengevaluasi ekspresi pada waktu kompilasi, kami ingin meminta ekspresi untuk dievaluasi pada waktu kompilasi; constexpr di depan definisi variabel melakukan itu (dan menyiratkan const):

Sebagai contoh:

constexpr int len1 = length("abcd") ;

Bjarne Stroustrup memberikan ringkasan kapan kami dapat memastikan evaluasi waktu kompilasi dalam entri blog isocpp ini dan mengatakan:

[...] Jawaban yang benar - seperti yang dinyatakan oleh Herb - adalah bahwa menurut standar fungsi constexpr dapat dievaluasi pada waktu kompilator atau waktu berjalan kecuali jika digunakan sebagai ekspresi konstan, dalam hal ini harus dievaluasi pada saat kompilasi -waktu. Untuk menjamin evaluasi waktu kompilasi, kita harus menggunakannya di mana ekspresi konstan diperlukan (misalnya, sebagai ikatan array atau sebagai label case) atau menggunakannya untuk menginisialisasi konsteks. Saya berharap bahwa tidak ada kompiler yang menghargai diri sendiri yang akan melewatkan peluang pengoptimalan untuk melakukan apa yang awalnya saya katakan: "Fungsi constexpr dievaluasi pada waktu kompilasi jika semua argumennya adalah ekspresi konstan."

Jadi ini menguraikan dua kasus yang harus dievaluasi pada waktu kompilasi:

1. Gunakan di mana ekspresi konstan diperlukan, ini akan tampak di mana saja dalam standar draf tempat frase shall be ... converted constant expressionatau shall be ... constant expressiondigunakan, seperti terikat larik.
2. Gunakan itu untuk menginisialisasi constexprseperti yang saya uraikan di atas.

Sangat mudah untuk mengetahui apakah panggilan ke suatu constexprfungsi menghasilkan ekspresi konstanta inti atau hanya dioptimalkan:

Gunakan dalam konteks di mana ekspresi konstan diperlukan.

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

Sebagai catatan, kompiler modern (seperti gcc-4.x) melakukannya strlenuntuk literal string pada waktu kompilasi karena biasanya didefinisikan sebagai fungsi intrinsik . Tanpa pengoptimalan yang diaktifkan. Meskipun hasilnya bukan konstanta waktu kompilasi.

Misalnya:

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

Hasil dalam:

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

Izinkan saya mengusulkan fungsi lain yang menghitung panjang string pada waktu kompilasi tanpa rekursif.

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

Lihat kode contoh ini di ideone .

Tidak ada jaminan bahwa suatu constexprfungsi dievaluasi pada waktu kompilasi, meskipun kompilator yang wajar akan melakukannya pada tingkat pengoptimalan yang sesuai diaktifkan. Di sisi lain, parameter template harus dievaluasi pada waktu kompilasi.

Saya menggunakan trik berikut untuk memaksa evaluasi pada waktu kompilasi. Sayangnya ini hanya bekerja dengan nilai integral (yaitu tidak dengan nilai floating point).

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

Sekarang, jika Anda menulis

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

Anda dapat yakin bahwa ifpernyataan tersebut adalah konstanta waktu kompilasi tanpa overhead waktu proses.

Penjelasan singkat dari entri Wikipedia tentang ekspresi konstanta yang digeneralisasi :

Penggunaan constexpr pada suatu fungsi menyebabkan beberapa batasan pada fungsi yang dapat dilakukan oleh fungsi tersebut. Pertama, fungsi tersebut harus memiliki tipe pengembalian non-void. Kedua, badan fungsi tidak dapat mendeklarasikan variabel atau mendefinisikan tipe baru. Ketiga, body hanya dapat berisi deklarasi, pernyataan null, dan pernyataan return tunggal. Harus ada nilai argumen sedemikian rupa sehingga, setelah substitusi argumen, ekspresi dalam pernyataan return menghasilkan ekspresi konstan.

Memiliki constexprkata kunci sebelum definisi fungsi menginstruksikan kompilator untuk memeriksa apakah batasan ini terpenuhi. Jika ya, dan fungsinya dipanggil dengan konstanta, nilai yang dikembalikan dijamin konstan dan dengan demikian dapat digunakan di mana pun ekspresi konstan diperlukan.