Lazy initialization of a static member array of a template class

Convert the arrays to 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>();

This does mean computing the x and w coefficients separately, though there are workarounds if this is less efficient, for example:

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());

First of all: you can't do initialization completely at compile-time using C++03 (yep, by design!) -- the only way to do it is to use C++ templates, but you'll unable to pass a double as template parameter.

Things getting better w/ C++11 -- you may use constexpr but only if your compute_legendre_coeffs() is trivial enough.

Or there is one trick I use when need to take some actions by fact of class declaration -- for example, register smth somewhere... to provide serialization capabilities via some library or smth like this.

You may use static constructors idiom to initalize that arrays... For simialr reasons I use the following code:

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;

then you have to inherit static_xtors class, and implement two static methods: void static_ctor() -- which would initialize your arrays, and empty (in your case) void static_dtor()... I.e. smth like this:

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];

As you may notice, x and w is not const anymore :( -- you may try to make them const again hiding to private and add static getters to be used by callers... Also, your internal arrays would be initialized at runtime, but before the main function (and just once)...

or play w/ constexpr... but seems you'll need to redesign you initializer function (somehow) because using initialization lists it should looks like this:

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

... and definitely you can't do it w/o specializing (and extensive macros usage). But probably variadic templates may help... need to know more details about your function and time to think :))

Maybe you can try turning your function into an initializer class template, whose parameter would be the class/struct you want to initialize. Then change that class template to include a constant instance of the initializer . Finally, have the constructor of the initializer class trigger the code doing the actual initialization.

You should perhaps also protect access [1] to the initializer class so that the initialization doesn't happen more than once.

The idea, as you can see, is to use the facts that class instances get their constructor code called, template instances get their constant data initialized.

Below is a possible (and simple) implementation, without 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;
};

Here's another take on it, this time putting the initialization in the struct directly:

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);
    }
};

The interesting characteristic of this solution is that the T_init constant instance shouldn't take any space within the T struct. The initialization logic is bundled with the class that needs it, and the T_init template only enables it automatically.

[1] Xeo mentioned the std::call_once template, which could come handy here.