模板化的迭代傳遞<N>回調函數

Question

我想運行一個編譯時的迭代器，如：

meta::reverse_iterator<2, 9>::iterate(callback()); 
meta::reverse_iterator<4, 7>::iterate(callback()); 
std::cout << "-----------------" << std::endl; 
meta::iterator<2, 9>::iterate(callback()); 
meta::iterator<4, 7>::iterate(callback()); 

struct callback { 
    template <int i> 
    void operator()() { 
    std::cout << "print !!" << i << std::endl; 
    } 
}; 

這是怎麼我寫的元迭代器：

namespace meta { 
    template <int Begin, int End, bool done = false> 
    struct reverse_iterator { 
     template <typename F> 
     static void iterate(F f) { 
      f.template operator()<End>(); 
      reverse_iterator<Begin, End-1, Begin == End-1>::iterate(f); 
     } 
    }; 

    template <int Begin, int End> 
    struct reverse_iterator<Begin, End, true> { 
     template <typename F> 
     static void iterate(F) {} 
    }; 

    template <int Begin, int End, bool done = false> 
    struct iterator { 
     template <typename F> 
     static void iterate(F f) { 
      iterator<Begin, End - 1, Begin == End - 1>::iterate(f); 
      f.template operator()<End - 1>(); 
     } 
    }; 

    template <int Begin, int End> 
    struct iterator<Begin, End, true> { 
     template <typename F> 
     static void iterate(F) {} 
    }; 

} 

權現在我迭代器調用operator()<N>但我希望它能夠調用用戶提供的任何函數與模板參數<N>（不作爲運行時參數）如何可以實現？

也boost::bind不能與它一起工作，因爲它調用綁定的函數對象而不是真正的函數。所以應該有一些方法來將默認參數傳遞給所提供的功能。

Answer 1

AFAIK你不能這樣做直接的，但如果你真的想你可以使用一個traits類調​​用成員函數你，並針對不同的成員函數編寫不同的特質：

struct function_operator_call_trait { 
    template< int N, class T > 
    void call(T& t) {t.template operator()<N>();} 
}; 
template< class Arg1, class Arg2 > 
struct foo_call_trait { 
    foo_call_trait(Arg1&& arg1) : a1(std::move(arg1)) {} 
    foo_call_trait(Arg1&& arg1, Arg2&& arg2) 
     : a1(std::move(arg1)), a2(std::move(arg2)) {} 
    template< class T, int N > 
    void call(T& t) {t.template foo<N>(a1, a2);} 
    Arg1 a1; 
    Arg2 a2; 
}; 
template <int Begin, int End, class traits = function_operator_call_trait, bool done = false> 
struct iterator{ 
    iterator() {} 
    iterator(traits const& t) : t_(t) {} 
    iterator(traits&& t) : t_(std::move(t)) {} 
    template<typename F> 
    static void iterate(F f){ 
     iterator<Begin, End-1, traits, Begin == End-1>::iterate(f); 
     t_.call<End-1>(f); 
    } 
    traits t_; 
}; 
typedef iterator<2, 9> fc_iterator; 
typedef foo_call_trait<int, float> foo_traits; 
typedef iterator<2, 9, foo_traits> foo_iterator(foo_traits(1, 2));