variadic टेम्पलेट्स तर्क

Question

मैं निम्नलिखित पैटर्न सामान्यीकरण करने के लिए चाहते हैं के ऊपर मेटा-यात्रा:

template<class A1, class A2, class A3> 
class Foo { 
protected: 
    template<class T> 
    void foo(const T& t) {...do stuff...} 
public: 
    void bar(const A1& a) { foo(a); } 
    void bar(const A2& a) { foo(a); } 
    void bar(const A3& a) { foo(a); } 
}; 

ऊपर दृष्टिकोण बढ़ रही बहस की संख्या के साथ पैमाने पर नहीं है। तो, मैं करना चाहता हूं:

template<class As...> 
class Foo { 
protected: 
    template<class T> 
    void foo(const t& a) {...do stuff...} 
public: 
    for each type A in As declare: 
    void bar(const A& a) { foo(a); } 
}; 

क्या ऐसा करने का कोई तरीका है?

Answer 1

मामले में आप वास्तव में bar रों की जरूरत नहीं है और इसके बजाय सिर्फ foo बाध्य करने की आवश्यकता - हम केवल एक प्रकार के लिए परिवर्तनीय के साथ यह करने के लिए एक कॉल अनुमति देने के लिए उपयोग कर सकते हैं SFINAE A रों में से एक:

template <class... As> 
class Foo { 
public: 
    template <class T, 
     class = std::enable_if_t<any<std::is_convertible<T, As>::value...>::value>> 
    void foo(T const&) { ... } 
}; 

हम कहाँकी तरह कुछ के साथ any लागू कर सकते हैंचाल:

template <bool... b> struct bool_pack { }; 
template <bool... b> 
using any = std::integral_constant<bool, 
    !std::is_same<bool_pack<b..., false>, bool_pack<false, b...>>::value>; 

Answer 2

template<class A, class Foo_t> 
class bar_t { 
public: 
    void bar(const A &a) { Foo_t::foo(a); } 
}; 


template<class ...As> 
class Foo : bar_t<As, Foo<As...> >... { 
protected: 
    template<class T> 
     void foo(const T& a) { /* do stuff */ } 
}; 

Answer 3

template <class CRTP, class A, class... As> 
struct FooBar 
{ 
    void bar(const A& a) 
    { 
     static_cast<CRTP*>(this)->foo(a); 
    } 
}; 

template <class CRTP, class A, class B, class... As> 
struct FooBar<CRTP, A, B, As...> : FooBar<CRTP, B, As...> 
{ 
    using FooBar<CRTP, B, As...>::bar; 

    void bar(const A& a) 
    { 
     static_cast<CRTP*>(this)->foo(a); 
    } 
}; 

template <class... As> 
class Foo : FooBar<Foo<As...>, As...> 
{ 
    template <class, class, class...> 
    friend struct FooBar; 

protected: 
    template <class T> 
    void foo(const T& a) { } 

public: 
    using FooBar<Foo, As...>::bar; 
}; 

DEMO

Answer 4

template <class A, class... As> 
class Foo : public Foo<As...> 
{ 
protected: 
    using Foo<As...>::foo; 
public: 
    using Foo<As...>::bar; 
    void bar(const A& a) { foo(a); } 
}; 

template <class A> 
class Foo<A> 
{ 
protected: 
    template <class T> 
    void foo(const T& t) { } 
public: 
    void bar(const A& a) { foo(a); } 
}; 

Piotr Skotnicki's answer लिए एक समान व्यर्थ में, इस टेम्पलेट तर्क के सभी के लिए bar भार के साथ एक वर्ग का निर्माण करने के उत्तराधिकार का उपयोग करता है। हालांकि यह थोड़ा सा क्लीनर है, केवल एक वर्ग टेम्पलेट के साथ ही आंशिक विशेषज्ञता है।

Answer 5

एक और दृष्टिकोण variadic अनुक्रम यदि प्रकार, और एक उपयोगी त्रुटि संदेश के साथ barf अनुक्रम में है परीक्षण करने के लिए, यह किसी भी विरासत चाल से बचने के ..

#include <iostream> 

struct E {}; 
struct F {}; 

template <class... As> 
class Foo 
{ 
    template <typename U> 
    static constexpr bool contains() { 
     return false; 
    } 

    template <typename U, typename B, typename ...S> 
    static constexpr bool contains() { 
     return (std::is_same<U, B>::value)? true : contains<U, S...>(); 
    } 

protected: 
    template <class T> 
    void foo(const T& a) { std::cout << __PRETTY_FUNCTION__ << std::endl; } 

public: 
    template <class T> 
    void bar(const T& a) { 
     static_assert(contains<T, As...>(), "Type does not exist"); 
     foo(a); 
    } 
}; 

int main() 
{ 
    Foo<E, F, E, F> f; 
    f.bar(F{}); 
    f.bar(E{}); 
    f.bar(1); // will hit static_assert 
}