การเริ่มต้น Lazy ของอาร์เรย์สมาชิกแบบคงที่ของคลาสเทมเพลต

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

การให้ accessor ทำให้คุณสามารถควบคุมจุดเข้าสู่ชั้นเรียนของคุณได้ ตัวเข้าถึงส่งไปยังฟังก์ชัน init ที่ใช้การเริ่มต้นของตัวแปรสแตติกในเครื่องเพื่อเรียก do_init เพียงครั้งเดียวตลอดอายุการใช้งานของโปรแกรม do_init ทำการกำหนดค่าเริ่มต้นจริงของสมาชิก

หมายเหตุ:

ขึ้นอยู่กับคอมไพลเลอร์ สิ่งนี้อาจไม่ปลอดภัยสำหรับเธรด (เช่น คอมไพเลอร์ C ++ 03 ไม่ใช่ทั้งหมดที่มีการเตรียมใช้งานตัวแปรสแตติกที่ปลอดภัยสำหรับเธรด ซึ่งหมายความว่า do_init อาจถูกเรียกใช้แบบขนานมากกว่าหนึ่งครั้ง ขึ้นอยู่กับอัลกอริทึมที่อาจ หรือไม่เป็นปัญหา --เช่น หาก do_init คำนวณค่าต่างๆ กันและเพียงแค่เขียนค่าเหล่านั้น สภาพการแข่งขันที่อาจเกิดขึ้นจะไม่เกี่ยวข้องเนื่องจากผลลัพธ์สุทธิจะเหมือนกัน) คอมไพเลอร์บางตัวเสนอกลไกเพื่อรับประกันการดำเนินการเพียงครั้งเดียว (ฉันเชื่อว่าบูสต์มีกลไกดังกล่าว) หรืออาจ เตรียม ค่าสัมประสิทธิ์ก่อนที่จะเริ่มเธรด ทั้งนี้ขึ้นอยู่กับโดเมนของคุณ

อาร์เรย์ที่แท้จริงไม่สามารถเป็น const ในกรณีนี้ เนื่องจากการเริ่มต้นจะต้องเกิดขึ้นหลังจากสร้างขึ้นแล้ว นั่นไม่ควรเป็นปัญหาสำหรับสิ่งอื่นใดนอกจากการเพิ่มประสิทธิภาพระดับไมโครที่เป็นไปได้ (เช่น คอมไพลเลอร์ไม่ทราบเกี่ยวกับค่าของสัมประสิทธิ์ ดังนั้นจึงไม่สามารถทำการประเมินนิพจน์ย่อยในเวลาคอมไพล์ได้)

แปลงอาร์เรย์เป็น 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>();

นี่หมายถึงการคำนวณค่าสัมประสิทธิ์ x และ w แยกกัน แม้ว่าจะมีวิธีแก้ปัญหาหากมีประสิทธิภาพน้อยกว่า เช่น:

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

ก่อนอื่น: คุณไม่สามารถเริ่มต้นได้อย่างสมบูรณ์ในเวลาคอมไพล์โดยใช้ C++03 (ใช่แล้ว โดยการออกแบบ!) -- วิธีเดียวที่จะทำได้คือใช้เทมเพลต C++ แต่คุณจะไม่สามารถผ่านสองเท่าได้ เป็นพารามิเตอร์เทมเพลต

สิ่งต่างๆ จะดีขึ้นด้วย C++11 คุณสามารถใช้ constexpr ได้ก็ต่อเมื่อ compute_legendre_coeffs() ของคุณไม่สำคัญเพียงพอเท่านั้น

หรือมีเคล็ดลับอย่างหนึ่งที่ฉันใช้เมื่อจำเป็นต้องดำเนินการบางอย่างตามความเป็นจริงของการประกาศคลาส ตัวอย่างเช่น ลงทะเบียน smth ที่ไหนสักแห่ง... เพื่อให้ความสามารถในการซีเรียลไลซ์ผ่านไลบรารี่หรือ smth เช่นนี้

คุณสามารถใช้ สำนวนคอนสตรัคเตอร์แบบคงที่ เพื่อเริ่มต้นอาร์เรย์นั้น... ด้วยเหตุผลที่คล้ายกัน ฉันใช้รหัสต่อไปนี้:

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;

จากนั้นคุณจะต้องสืบทอดคลาส static_xtors และใช้วิธีคงที่สองวิธี: void static_ctor() -- ซึ่งจะเริ่มต้นอาร์เรย์ของคุณ และว่างเปล่า (ในกรณีของคุณ) void static_dtor()... นั่นคือ แบบนี้:

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

ดังที่คุณอาจสังเกตเห็นว่า x และ w ไม่ใช่ const อีกต่อไป :( -- คุณอาจลองทำให้ const ซ่อนเป็น private อีกครั้ง และเพิ่ม getters แบบคงที่เพื่อให้ผู้โทรใช้... นอกจากนี้ อาร์เรย์ภายในของคุณจะถูกเตรียมใช้งานเมื่อรันไทม์ แต่ ก่อน ฟังก์ชัน main (และเพียงครั้งเดียว)...

หรือเล่นด้วย constexpr... แต่ดูเหมือนว่าคุณจะต้องออกแบบฟังก์ชันตัวเริ่มต้นใหม่ (อย่างใด) เพราะการใช้รายการเริ่มต้นควรมีลักษณะดังนี้:

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

... และแน่นอนว่าคุณไม่สามารถทำได้หากไม่มีความเชี่ยวชาญ (และการใช้มาโครอย่างกว้างขวาง) แต่เทมเพลตที่หลากหลายอาจช่วยได้... จำเป็นต้องทราบรายละเอียดเพิ่มเติมเกี่ยวกับฟังก์ชันและเวลาในการคิดของคุณ :))

บางทีคุณอาจลองเปลี่ยนฟังก์ชันของคุณให้เป็นเทมเพลตคลาส Initializer ซึ่งพารามิเตอร์จะเป็นคลาส/โครงสร้างที่คุณต้องการเริ่มต้น จากนั้นเปลี่ยนเทมเพลตคลาสนั้นเพื่อรวมอินสแตนซ์คงที่ของตัวเริ่มต้น สุดท้าย ให้ Constructor ของคลาส Initializer ทริกเกอร์โค้ดที่ทำการเริ่มต้นจริง

บางทีคุณควรป้องกันการเข้าถึง [1] ให้กับคลาส Initializer เพื่อไม่ให้การเริ่มต้นเกิดขึ้นมากกว่าหนึ่งครั้ง

อย่างที่คุณเห็น แนวคิดก็คือการใช้ข้อเท็จจริงที่ว่าคลาสอินสแตนซ์ได้รับการเรียกโค้ดคอนสตรัคเตอร์ อินสแตนซ์เทมเพลตได้รับการเตรียมใช้งานข้อมูลคงที่

ด้านล่างนี้เป็นการใช้งานที่เป็นไปได้ (และเรียบง่าย) โดยไม่มีเทมเพลต:

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

นี่เป็นอีกวิธีหนึ่ง คราวนี้เป็นการวางการกำหนดค่าเริ่มต้นใน struct โดยตรง:

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

ลักษณะที่น่าสนใจของโซลูชันนี้คืออินสแตนซ์ค่าคงที่ T_init ไม่ควรมีพื้นที่ว่างภายในโครงสร้าง T ตรรกะการเริ่มต้นจะรวมเข้ากับคลาสที่ต้องการ และเทมเพลต T_init จะเปิดใช้งานโดยอัตโนมัติเท่านั้น

[1] Xeo กล่าวถึงเทมเพลต std::call_once ซึ่งอาจมีประโยชน์ที่นี่