Inisialisasi lambat dari array anggota statis dari kelas templat

template <size_t n>
class legendre
{
public:
    static const size_t size = n;
    static const double (&getX())[n] {
       init();
       return x;
    }
    static const double (&getW())[n] {
       init();
       return x;
    }
private:
    static double x[n];
    static double w[n];
    static void init() {
       static bool _ = do_init(x,y);
    }
    static bool do_init( double *x, double *y ) {
       // do the computation here, use local vars x, y
       return true;
    }
};
template <size_t n>
double legendre<n>::x[n];
template <size_t n>
double legendre<n>::w[n];

Dengan menyediakan pengakses, Anda mendapatkan kendali atas titik masuk ke kelas Anda. Pengakses mengirimkan ke fungsi init yang menggunakan inisialisasi variabel statis lokal untuk memanggil do_init hanya sekali seumur hidup program. do_init melakukan inisialisasi anggota yang sebenarnya.

Catatan:

Tergantung pada kompilernya, ini mungkin tidak aman untuk thread (yaitu tidak semua kompiler C++03 menyediakan inisialisasi variabel statis yang aman untuk thread, yang pada gilirannya berarti bahwa do_init mungkin dipanggil lebih dari sekali secara paralel, tergantung pada algoritma yang mungkin atau tidak menjadi masalah --yaitu jika do_init menghitung nilai-nilai tersebut dan hanya menuliskannya, kondisi balapan potensial tidak relevan karena hasil akhirnya akan sama). Beberapa kompiler menawarkan mekanisme untuk menjamin eksekusi satu kali (saya yakin boost memiliki mekanisme seperti itu). Alternatifnya, bergantung pada domain Anda, Anda mungkin dapat memprioritaskan koefisien sebelum memulai thread.

Array sebenarnya tidak boleh const dalam kasus ini, karena inisialisasi harus dilakukan setelah dibuat. Hal ini seharusnya tidak menjadi masalah selain kemungkinan optimasi mikro (yaitu kompiler tidak mengetahui nilai koefisien, sehingga tidak dapat melakukan evaluasi sub-ekspresi pada waktu kompilasi).

Ubah array menjadi std::array:

#include <array>
template<int n> struct legendre {
    static const std::array<double, n> x;
};
void compute_xs(int n, double *xs) {
    ...
}
template<int n> std::array<double, n> make_xs() {
    std::array<double, n> xs;
    compute_xs(n, xs.data());
    return xs;
}
template<int n> const std::array<double, n> legendre<n>::x = make_xs<n>();

Ini berarti menghitung koefisien x dan w secara terpisah, meskipun ada solusi jika hal ini kurang efisien, misalnya:

template<int n> struct legendre_coeffs {
    std::array<double, n> x, w;
    legendre_coeffs(): x(), w() { compute_legendre_coeffs(n, w.data(), x.data()); }
};
template<int n> struct legendre {
    static const legendre_coeffs coeffs;
    static const double (&x)[n], (&w)[n];
};
template<int n> const legendre_coeffs legendre<n>::coeffs;
template<int n> const double (&legendre<n>::x)[n]
    = *reinterpret_cast<const double (*)[n]>(legendre<n>::coeffs::x.data());
template<int n> const double (&legendre<n>::w)[n]
    = *reinterpret_cast<const double (*)[n]>(legendre<n>::coeffs::w.data());

Pertama-tama: Anda tidak dapat melakukan inisialisasi sepenuhnya pada waktu kompilasi menggunakan C++03 (ya, memang disengaja!) -- satu-satunya cara untuk melakukannya adalah dengan menggunakan templat C++, tetapi Anda tidak akan dapat melewati double sebagai parameter templat.

Segalanya menjadi lebih baik dengan C++11 -- Anda dapat menggunakan constexpr tetapi hanya jika compute_legendre_coeffs() Anda cukup sepele.

Atau ada satu trik yang saya gunakan ketika perlu mengambil beberapa tindakan berdasarkan deklarasi kelas -- misalnya, mendaftarkan sesuatu di suatu tempat... untuk menyediakan kemampuan serialisasi melalui beberapa perpustakaan atau sesuatu seperti ini.

Anda dapat menggunakan idiom konstruktor statis untuk menginisialisasi array itu... Untuk alasan serupa saya menggunakan kode berikut:

template <
    typename Derived
  , typename Target = Derived
>
class static_xtors
{
    // This class will actually call your static init methods...
    struct helper
    {
        helper()
        {
        Target::static_ctor();
        }

        ~helper()
        {
        Target::static_dtor();
        }
    };
    // ... because your derived class would inherit this member from static_xtor base
    static helper s_helper;

    // The rest is needed to force compiler to instantiate everything required stuff
    // w/o eliminate as unused...
    template <void(*)()>
    struct helper2 {};

    static void use_helper()
    {
    (void)s_helper;
    }
    helper2<&static_xtors::use_helper> s_helper2;

    virtual void use_helper2()
    {
    (void)s_helper2;
    }

public:
    /// this is not required for your case... only if later you'll have
    /// a hierarchy w/ virtuals
    virtual ~static_xtors() {}
};

template <
    typename Derived
, typename Target
>
typename static_xtors<Derived, Target>::helper
static_xtors<Derived, Target>::s_helper;

maka Anda harus mewarisi kelas static_xtors, dan mengimplementasikan dua metode statis: void static_ctor() -- yang akan menginisialisasi array Anda, dan mengosongkan (dalam kasus Anda) void static_dtor()... Yaitu. sesuatu seperti ini:

template <size_t n>
struct legendre : public static_xtors<legendre<n>>
{
    static const size_t size = n;
    static double x[n];
    static double w[n];

    static void static_ctor()
    {
        compute_legendre_coeffs(n, x, w);
    }
    static void static_dtor()
    {
        // nothing to do
    }
};

template <size_t n>
static double legendre<n>::x[n];

template <size_t n>
static double legendre<n>::w[n];

Seperti yang mungkin Anda perhatikan, x dan w bukan const lagi :( -- Anda dapat mencoba membuatnya const lagi bersembunyi di private dan menambahkan pengambil statis untuk digunakan oleh pemanggil... Selain itu, array internal Anda akan diinisialisasi saat runtime, tapi sebelum fungsi main (dan hanya sekali)...

atau mainkan dengan constexpr... tetapi sepertinya Anda harus mendesain ulang fungsi penginisialisasi Anda (entah bagaimana) karena menggunakan daftar inisialisasi akan terlihat seperti ini:

template <size_t n>
static double legendre<n>::x[n] = { calc_coeff_x<0>(), calc_coeff_x<1>(), calc_coeff_x<2>(), ... }

... dan tentunya Anda tidak dapat melakukannya tanpa spesialisasi (dan penggunaan makro yang ekstensif). Tapi mungkin templat variadik dapat membantu... perlu mengetahui lebih detail tentang fungsi Anda dan waktu untuk berpikir :))

Mungkin Anda dapat mencoba mengubah fungsi Anda menjadi templat kelas penginisialisasi, yang parameternya adalah kelas/struktur yang ingin Anda inisialisasi. Kemudian ubah templat kelas itu untuk menyertakan instance penginisialisasi yang konstan. Terakhir, minta konstruktor kelas penginisialisasi memicu kode untuk melakukan inisialisasi sebenarnya.

Anda mungkin juga harus melindungi akses [1] ke kelas penginisialisasi sehingga inisialisasi tidak terjadi lebih dari sekali.

Idenya, seperti yang Anda lihat, adalah dengan menggunakan fakta bahwa instance kelas memanggil kode konstruktornya, instance template menginisialisasi data konstannya.

Di bawah ini adalah implementasi yang mungkin (dan sederhana), tanpa template:

struct legendre_init {
    legendre_init(){
        compute_legendre_coeffs (T::n, T::w, T::x);
    }
 };


template <size_t n>
struct legendre
{
    typedef legendre<n> self_type;
    static const size_t size = n;
    static const double x[n];
    static const double w[n];
    static const legendre_init _l;
};

Berikut ini cara lain, kali ini menempatkan inisialisasi di struct secara langsung:

template <class T>
class T_init {
    public:
    T_init(){
        T::_init();
    }
 };


template <size_t n>
struct legendre
{
    typedef legendre<n> self_type;
    static const size_t size = n;
    static const double x[n];
    static const double w[n];
    static const T_init<self_type> _f;
    static void _init(){
        compute_legendre_coeffs (self_type::n, self_type::w, self_type::x);
    }
};

Karakteristik menarik dari solusi ini adalah instance konstan T_init tidak boleh mengambil ruang apa pun di dalam T struct. Logika inisialisasi digabungkan dengan kelas yang memerlukannya, dan templat T_init hanya mengaktifkannya secara otomatis.

[1] Xeo menyebutkan template std::call_once, yang mungkin berguna di sini.