Bagaimanakah Kita Boleh Mengoptimumkan Pelaksanaan `make_integer_sequence` C 14 untuk Mengelakkan Keletihan Memori?

Penerangan tentang Pelaksanaan make_integer_sequence C 14

Dalam C 14, templat alias make_integer_sequence telah diperkenalkan untuk memudahkan penciptaan templat kelas integer_sequence. Untuk melaksanakan make_integer_sequence, struktur pembantu, make_helper, digunakan.

template< class T, T... I> struct integer_sequence
{
    typedef T value_type;
    static constexpr size_t size() noexcept { return sizeof...(I) ; }

};

template< class T, T N>
using make_integer_sequence = integer_sequence< T, 0,1,2, ... ,N-1 >; // only for illustration.

Di sinilah isu itu timbul. Dalam pelaksanaan anda, struktur make_helper menggunakan pendekatan rekursif. Walaupun ini mungkin kelihatan seperti penyelesaian yang mudah, ia boleh membawa kepada peningkatan pesat dalam instantiasi templat, terutamanya apabila parameter N adalah besar.

template< class T, T N, T... I >
struct make_helper
{
   typedef typename mpl::if_< T(0) == N,  
                  mpl::identity< integer_sequence<T,I...> >,
                  make_helper< T, N-1, N-1,I...> 
               >::type;
};

Disebabkan pertumbuhan eksponen ini, pengkompil boleh menghabiskan memori maya dengan cepat , seperti yang anda hadapi semasa anda menukar makro GEN untuk menjana jujukan integer dengan gandaan 4.

Kedalaman Logaritma Pelaksanaan

Isu keletihan ingatan boleh diatasi dengan menggunakan pelaksanaan kedalaman logaritma. Pendekatan ini meminimumkan bilangan panggilan rekursif, mengurangkan kedalaman instantiasi templat.

template<unsigned...> struct seq{ using type = seq; };

template<class S1, class S2> struct concat;

template<unsigned... I1, unsigned... I2>
struct concat<seq<I1...>, seq<I2...>>
  : seq<I1..., (sizeof...(I1)+I2)...>{};

template<class S1, class S2>
using Concat = Invoke<concat<S1, S2>>;

template<unsigned N> struct gen_seq;
template<unsigned N> using GenSeq = Invoke<gen_seq<N>>;

template<unsigned N>
struct gen_seq : Concat<GenSeq<N/2>, GenSeq<N - N/2>>{};

template<> struct gen_seq<0> : seq<>{};
template<> struct gen_seq<1> : seq<0>{};

Dalam pelaksanaan kedalaman logaritma ini, kedalaman rekursif berkembang secara logaritma dengan N. Ini mengurangkan penggunaan memori dengan ketara dan membolehkan penyusunan jujukan integer dengan nilai N yang jauh lebih besar.

Dengan menggunakan pelaksanaan kedalaman logaritma, isu asal keletihan memori maya diselesaikan, membolehkan penjanaan jujukan integer dengan nilai besar N.

Atas ialah kandungan terperinci Bagaimanakah Kita Boleh Mengoptimumkan Pelaksanaan `make_integer_sequence` C 14 untuk Mengelakkan Keletihan Memori?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!