Apakah variabel constexpr statis di dalam suatu fungsi masuk akal?

Jika saya memiliki variabel di dalam suatu fungsi (katakanlah, array besar), apakah masuk akal untuk menyatakan keduanya staticdan constexpr? constexprmenjamin bahwa array dibuat pada waktu kompilasi, jadi apakah statictidak akan berguna?

void f() {
    static constexpr int x [] = {
        // a few thousand elements
    };
    // do something with the array
}

Apakah staticbenar - benar melakukan sesuatu di sana dalam hal kode atau semantik yang dihasilkan?

Jawaban singkatnya adalah bahwa tidak hanya staticberguna, itu cukup baik selalu akan diinginkan.

Pertama, perhatikan itu staticdan constexprsepenuhnya independen satu sama lain. staticmendefinisikan umur objek selama eksekusi; constexprmenentukan bahwa objek harus tersedia selama kompilasi. Kompilasi dan eksekusi saling terpisah dan terpisah, baik dalam waktu maupun ruang. Jadi begitu program dikompilasi, constexprtidak lagi relevan.

Setiap variabel yang dideklarasikan constexprsecara implisit consttetapi constdan statichampir ortogonal (kecuali untuk interaksi dengan static constbilangan bulat).

Model C++objek (§1.9) mensyaratkan bahwa semua objek selain dari bit-field menempati setidaknya satu byte memori dan memiliki alamat; selanjutnya semua objek yang dapat diamati dalam program pada saat tertentu harus memiliki alamat yang berbeda (paragraf 6). Ini tidak cukup membutuhkan kompilator untuk membuat array baru di stack untuk setiap pemanggilan fungsi dengan array const non-statis lokal, karena kompiler dapat berlindung pada as-ifprinsip asalkan dapat membuktikan bahwa tidak ada objek lain yang dapat dibuat. diamati.

Sayangnya, itu tidak mudah dibuktikan, kecuali fungsinya sepele (misalnya, tidak memanggil fungsi lain yang badannya tidak terlihat di dalam unit terjemahan) karena array, kurang lebih menurut definisi, adalah alamat. Jadi dalam kebanyakan kasus, const(expr)array non-statis harus dibuat ulang pada stack di setiap doa, yang mengalahkan titik untuk dapat menghitungnya pada waktu kompilasi.

Di sisi lain, static constobjek lokal dibagi oleh semua pengamat, dan selanjutnya dapat diinisialisasi bahkan jika fungsi yang didefinisikan tidak pernah disebut. Jadi tidak ada satu pun di atas yang berlaku, dan kompiler bebas tidak hanya untuk menghasilkan hanya satu instance saja; itu gratis untuk menghasilkan satu contoh dari itu dalam penyimpanan read-only.

Jadi, Anda harus menggunakan static constexprcontoh Anda.

Namun, ada satu kasus di mana Anda tidak ingin menggunakannya static constexpr. Kecuali constexprobjek yang dideklarasikan digunakan atau dideklarasikan ODRstatic , kompiler bebas untuk tidak memasukkannya sama sekali. Itu cukup berguna, karena memungkinkan penggunaan constexprarray sementara waktu kompilasi tanpa mencemari program yang dikompilasi dengan byte yang tidak perlu. Dalam hal ini, Anda jelas tidak ingin menggunakan static, karena statickemungkinan akan memaksa objek ada saat runtime.

Selain jawaban yang diberikan, perlu dicatat bahwa kompiler tidak diharuskan untuk menginisialisasi constexprvariabel pada waktu kompilasi, mengetahui bahwa perbedaan antara constexprdan static constexprapakah untuk menggunakan static constexprAnda memastikan variabel diinisialisasi hanya sekali.

Kode berikut menunjukkan bagaimana constexprvariabel diinisialisasi beberapa kali (dengan nilai yang sama), sedangkan static constexprpasti diinisialisasi hanya sekali.

Selain itu, kode membandingkan keuntungan constexprmelawan constdalam kombinasi dengan static.

#include <iostream>
#include <string>
#include <cassert>
#include <sstream>

const short const_short = 0;
constexpr short constexpr_short = 0;

// print only last 3 address value numbers
const short addr_offset = 3;

// This function will print name, value and address for given parameter
void print_properties(std::string ref_name, const short* param, short offset)
{
    // determine initial size of strings
    std::string title = "value \\ address of ";
    const size_t ref_size = ref_name.size();
    const size_t title_size = title.size();
    assert(title_size > ref_size);

    // create title (resize)
    title.append(ref_name);
    title.append(" is ");
    title.append(title_size - ref_size, ' ');

    // extract last 'offset' values from address
    std::stringstream addr;
    addr << param;
    const std::string addr_str = addr.str();
    const size_t addr_size = addr_str.size();
    assert(addr_size - offset > 0);

    // print title / ref value / address at offset
    std::cout << title << *param << " " << addr_str.substr(addr_size - offset) << std::endl;
}

// here we test initialization of const variable (runtime)
void const_value(const short counter)
{
    static short temp = const_short;
    const short const_var = ++temp;
    print_properties("const", &const_var, addr_offset);

    if (counter)
        const_value(counter - 1);
}

// here we test initialization of static variable (runtime)
void static_value(const short counter)
{
    static short temp = const_short;
    static short static_var = ++temp;
    print_properties("static", &static_var, addr_offset);

    if (counter)
        static_value(counter - 1);
}

// here we test initialization of static const variable (runtime)
void static_const_value(const short counter)
{
    static short temp = const_short;
    static const short static_var = ++temp;
    print_properties("static const", &static_var, addr_offset);

    if (counter)
        static_const_value(counter - 1);
}

// here we test initialization of constexpr variable (compile time)
void constexpr_value(const short counter)
{
    constexpr short constexpr_var = constexpr_short;
    print_properties("constexpr", &constexpr_var, addr_offset);

    if (counter)
        constexpr_value(counter - 1);
}

// here we test initialization of static constexpr variable (compile time)
void static_constexpr_value(const short counter)
{
    static constexpr short static_constexpr_var = constexpr_short;
    print_properties("static constexpr", &static_constexpr_var, addr_offset);

    if (counter)
        static_constexpr_value(counter - 1);
}

// final test call this method from main()
void test_static_const()
{
    constexpr short counter = 2;

    const_value(counter);
    std::cout << std::endl;

    static_value(counter);
    std::cout << std::endl;

    static_const_value(counter);
    std::cout << std::endl;

    constexpr_value(counter);
    std::cout << std::endl;

    static_constexpr_value(counter);
    std::cout << std::endl;
}

Output program yang mungkin:

value \ address of const is               1 564
value \ address of const is               2 3D4
value \ address of const is               3 244

value \ address of static is              1 C58
value \ address of static is              1 C58
value \ address of static is              1 C58

value \ address of static const is        1 C64
value \ address of static const is        1 C64
value \ address of static const is        1 C64

value \ address of constexpr is           0 564
value \ address of constexpr is           0 3D4
value \ address of constexpr is           0 244

value \ address of static constexpr is    0 EA0
value \ address of static constexpr is    0 EA0
value \ address of static constexpr is    0 EA0

Seperti yang Anda lihat sendiri, constexprbeberapa kali tidak staticdiinisiasi (alamat tidak sama) sementara kata kunci memastikan bahwa inisialisasi dilakukan hanya sekali.