पैरामीटर पैक को कैसे विभाजित करें?

Question

मैं एक फ़ंक्शन टेम्पलेट, apply लिखना चाहता हूं, जो कुछ फ़ंक्शन f, एक पूर्णांक i, और एक पैरामीटर पैक प्राप्त करता है। apply को पैरामीटर अनपैक करने और f लागू करने की आवश्यकता है, i वें पैरामीटर, pi को छोड़कर। pi के लिए, इसे f पर पैरामीटर के रूप में पास करने से पहले इसे किसी अन्य फ़ंक्शन g पर कॉल करने की आवश्यकता है।

ऐसा लगता है कि मुझे बाएं तरफ पैरामीटर पैक को विभाजित करने का तरीका चाहिए, i वें पैरामीटर, और दाएं तरफ। क्या यह संभव है? कोड में:

template<int i, typename Function, typename... Parms> 
    void apply(Function f, Parms... parms) 
{ 
    auto lhs = // what goes here? 
    auto pi = // what goes here? 
    auto rhs = // what goes here? 

    f(lhs..., g(pi), rhs...); 
} 

Answer 1

ठीक है, हम यहां जाते हैं! यह वास्तव में बदसूरत है लेकिन मैं जल्दी में एक अच्छे संस्करण के साथ नहीं आ सकता था;) अधिकांश सामान मानक मानक टेम्पलेट विशेषज्ञता है। सबसे बड़ा मुद्दा उचित आकार के पूर्णांक की एक सूची बना रहा है। मुझे याद है कि मैं एक अच्छे संस्करण के साथ आया लेकिन किसी भी तरह से मैं याद नहीं कर सकता कि मैंने क्या किया। का आनंद लें!

#include <iostream> 
#include <utility> 

// printing the values 
void print_args() {} 
template <typename F> void print_args(F f) { std::cout << f; } 
template <typename F, typename... T> 
void print_args(F f, T... args) 
{ 
    std::cout << f << ", "; 
    print_args(args...); 
} 

// the function object to be called: 
struct Functor 
{ 
    template <typename... T> 
    void operator()(T... args) 
    { 
     std::cout << "f("; 
     print_args(args...); 
     std::cout << ")\n"; 
    } 
}; 

// conditionally apply g(): 
template <typename T> T g(T value) { return 1000 + value; } 
template <int i, int j, typename T> 
typename std::enable_if<i != j, T>::type forward(T t) { return t; } 
template <int i, int j, typename T> 
typename std::enable_if<i == j, T>::type forward(T t) { return g(t); } 

// create a series of integers: 
template <int... Values> struct values {}; 

template <int Add, typename> struct combine_values; 
template <int Add, int... Values> 
struct combine_values<Add, values<Values...>> 
{ 
    typedef values<Values..., Add> type; 
}; 

template <int Size> struct make_values; 
template <> struct make_values<0> { typedef values<> type; }; 
template <int Size> 
struct make_values 
{ 
    typedef typename combine_values<Size, typename make_values<Size -1>::type>::type type; 
}; 

// applying f(t...) except for ti where g(ti) is called 
template <int i, int... Values, typename Function, typename... T> 
void apply_aux(values<Values...>, Function f, T... t) 
{ 
    f(forward<i, Values>(t)...); 
} 

template <int i, typename Function, typename... T> 
void apply(Function f, T... t) 
{ 
    apply_aux<i>(typename make_values<sizeof...(T)>::type(), f, t...); 
} 

int main() 
{ 
    apply<3>(Functor(), 1, 2, 3, 4, 5, 6, 7, 8); 
    apply<4>(Functor(), 1, 2, 3, 4, 5, 6, 7, 8); 
    apply<5>(Functor(), 1, 2, 3, 4, 5, 6, 7, 8); 
} 

Answer 2

वास्तव में कुछ समय पहले कोड कुछ ऐसा ही किया। तो निम्न कोड का प्रयास करें:

template<unsigned N, unsigned M> 
struct call_up_impl{ 
    template<class Func, class Mutator, class Tuple, class... Args> 
    static void do_call(const Func& func, const Mutator& mutator, const Tuple& args, Args&&... unpacked_args) { 
     call_up_impl<N-1, M>::do_call(func, mutator, args, std::get<N-1>(args), std::forward<Args>(unpacked_args)...); 
    } 
}; 

template<unsigned M> 
struct call_up_impl<0, M> { 
    template<class Func, class Mutator, class Tuple, class... Args> 
    static void do_call(const Func& func, const Mutator&, const Tuple&, Args&&... unpacked_args) { 
     func(std::forward<Args>(unpacked_args)...); 
    } 
}; 
template<unsigned M> 
struct call_up_impl<M, M> { 
    template<class Func, class Mutator, class Tuple, class... Args> 
    static void do_call(const Func& func, const Mutator& mutator, const Tuple& args, Args&&... unpacked_args) { 
     call_up_impl<M-1, M>::do_call(func, mutator, args, mutator(std::get<M-1>(args)), std::forward<Args>(unpacked_args)...); 
    } 
}; 
template<int i, typename Function, typename... Parms> 
void apply(Function f, Parms... parms) { 
     std::tuple<Parms...> t(parms...); 
     call_up_impl<std::tuple_size<decltype(t)>::value, i + 1>::do_call(f, &g, t); 
} 

यह मेरा मूल कोड की एक त्वरित रूपांतरण है, इसलिए यह अच्छी तरह से परीक्षण नहीं किया गया है और हो सकता है नहीं यह करने के लिए नहीं इष्टतम तरीका है, लेकिन यह कम से कम (कम से कम काम करना चाहिए एक त्वरित परीक्षण के अनुसार और आप वास्तव में क्या चाहते हैं के आधार पर)। बिना टपले के ऐसा करना संभव होना चाहिए, लेकिन मुझे यह नहीं मिला है कि जी ++ के साथ संकलन करें (यह आवश्यक घोंसला वाले चरम टेम्पलेट्स की तरह प्रतीत नहीं होता है)। हालांकि करने के लिए apply बदल रहा:

template<int i, typename Function, typename... Parms> 
void apply(Function f, Parms&&... parms) { 
     std::tuple<Parms&&...> t(std::forward<Parms>(parms)...); 
     call_up_impl<std::tuple_size<decltype(t)>::value, i + 1>::do_call(f, &g, t); 
} 

शायद भूमि के ऊपर टपल द्वारा शुरू की सबसे अधिक से बचने जाएगा। std::get कॉल के परिणामों की सही अग्रेषण करना बेहतर होगा, लेकिन अब मैं लिखने के लिए बहुत थक गया हूं।