Comment dérouler une courte boucle en C++

La solution la plus simple pour cela est d'écrire une boucle où les valeurs début et fin sont connus:

for(int i = 2; i <= 4; i++) {
  a[i]=b[i]; 
}

Je pense que c'est mieux que de n'importe quel modèle ou d'exécution-l'appel de mélange: La boucle comme l'écrit est tout à fait clair pour les compilateurs' optimiseur, et il n'y a pas de niveaux de la fonction appels à creuser par le biais de juste pour voir ce qu'il se passe.

OriginalL'auteur

Vous pouvez probablement faire quelque chose comme ce qui suit. En fonction de votre compilateur et le optimziation les paramètres que vous utilisez, vous peut obtenir l'effet que vous recherchez.

Être conscient que pour les petits objets comme char, il pourrait bien être plus lent qu'un std::copy ou un memcpy et que, pour les objets plus grands, le coût d'une boucle est susceptible d'être insignifiant par rapport aux copies sur en tout cas.

#include <cstddef>

template<std::size_t base, std::size_t count, class T, class U>
struct copy_helper
{
    static void copy(T dst, U src)
    {
        dst[base] = src[base];
        copy_helper<base + 1, count - 1, T, U>::copy(dst, src);
    }
};

template<std::size_t base, class T, class U>
struct copy_helper<base, 0, T, U>
{
    static void copy(T, U)
    {
    }
};

template<std::size_t base, std::size_t count, class T, class U>
void copy(T dst, U src)
{
    copy_helper<base, count, T, U>::copy(dst, src);
}

template void copy<5, 9, char*, const char*>(char*, const char*);

#include <iostream>
#include <ostream>

int main()
{
    const char test2[] = "     , World\n";
    char test[14] = "Hello";

    copy<5, 9>(test, test2);

    std::cout << test;

    return 0;
}

OriginalL'auteur CB Bailey

Il n'utilise pas de modèles et il n'est pas "complet" déroulage, mais vous pouvez partiellement dérouler la boucle avec quelque chose comme ceci:

void copy (SomeType* a, SomeType* b, int start_index, int num_items) {
    int i = start_index;

    while (num_items > 4) {
            a[i+0] = b[i+0];
            a[i+1] = b[i+1];
            a[i+2] = b[i+2];
            a[i+3] = b[i+3];
            i += 4;
            num_items -= 4;
    }
    while (num_items > 0) {
            a[i] = b[i];
            ++i;
            --num_items;
    }
}

Maintenant, dans cet exemple particulier, les calculs impliqués probablement l'emportent sur les avantages à partir de seulement dérouler les quatre éléments à la fois. Vous devriez obtenir une augmentation de bénéficier d'un nombre croissant d'éléments à l'intérieur de la boucle du haut (sur l'ensemble de la fonction, remplacer 4 avec toutefois de nombreux éléments que vous copiez à l'intérieur de chaque manuellement déroulé itération).

OriginalL'auteur bta

Boucle unrolloing à l'aide de méta-programmation peut être utilisé pour créer constexpr (je n'ai pas mesuré le temps). J'ai un exemple où il peut être utilisé pour faire de la fonction de combinaison(n, k) un cosntexpr:

template <size_t N> struct iterate_forward {
    template <class operation> static auto eval(const operation & op)
    {
        iterate_forward<N-1>::eval(op);
        return op(N-1);
    }
};
template <> struct iterate_forward<1>
{
    template <class operation> static auto eval(const operation & op)
    { return op(0); }
};
template <> struct iterate_forward<0>
{
    template <class operation> static auto eval(const operation & op) {}
};
template <size_t N, size_t K> constexpr size_t COMB()
{
    struct ratio
    {
        size_t operator () (size_t i) const { return (res *= (N-i) / (i+1)); }
        mutable size_t res = 1;
    };
    return iterate_forward<K>::eval(ratio());
} 

OriginalL'auteur Marco

#define tl template
#define tn typename
#define st struct
#define cl class
#define us using
template<tn A> st Typ { using type = A; };
tl<tn T> using GetT = tn T::type;
tl<tn F, tn ...As> us apply = tn F::tl apply<As...>;
tl<tn, tn, tn ...> st LoopElements;
tl<tn, tn> st Loop;
tl<tn, tn, tn> st VLoop_i;
tl<tn Sq, tn MF> us VLoop = VLoop_i<GetT<Sq>, Sq, MF>;
//
//TY
//
template<tn T> struct Ty {
template<T ...> struct Pack : Typ<T> {};
tl<tn ...> st Concat_i; tl<tn ...P> us Concat = GetT<Concat_i<P...>>;
tl<T, int64_t> st Seq_i; tl<T f, T t> us Seq = GetT<Seq_i<f, ((int64_t)(t - f))>>; tl<int64_t, tn> st add;
template<tl<T ...> tn C, T ...vs, tl<T ...> tn D, T ...ws, tn ...R> st Concat_i<C<vs...>, D<ws...>, R...> : Typ<Concat<C<vs..., ws...>, R...> >{};
template<tl<T ...> tn C, T ...vs> st Concat_i<C<vs...>> : Typ<C<vs...> >{};
template<int64_t x, T ...vs> struct add<x, Pack<vs...>> : Typ<Pack<((T)(vs + x))...>> {};
template<T f, int64_t c> class Seq_i {
using A = tn Seq_i<f, c/2>::type;
using B = tn add<c/2, A>::type;
using C = tn Seq_i<f + c / 2 * 2, c & 1>::type;
public:
using type = Concat<A, B, C>;
};
tl<T f> st Seq_i<f, 0> : Typ<Pack<>> {};        
tl<T f> st Seq_i<f, 1> : Typ<Pack<f>> {};
tl<T f> st Seq_i<f, -1> : Typ<Pack<f>> {};
};
//
//LOOP
template<size_t i, tn F, tn T> struct LoopElement { LoopElement() { apply<F, T>(); }; };
template<size_t ...is, tn F, tn ...P> struct LoopElements<Ty<size_t>::Pack<is...>, F, P...> : LoopElement<is, F, P>... {};
template<tn F, tl<tn ...> cl C, tn ...P> struct Loop<F, C<P...>> : LoopElements<Ty<size_t>::Seq<0, sizeof...(P)>, F, P...> {};
template<tn T, tl<T ...> cl ST, T ...vs, tn MF> struct VLoop_i<T, ST<vs...>, MF> : LoopElements<Ty<size_t>::Seq<0, sizeof...(vs)>, MF, Val<T, vs>...> {};

OriginalL'auteur user7414920