एक सक्षम_ifed टेम्पलेट टेम्पलेट कन्स्ट्रक्टर का प्रकार हस्ताक्षर?

Question

मैं आमतौर पर अपने वर्गों और टेम्पलेट्स की घोषणा करता हूं, और फिर उनके तरीकों को परिभाषित करता हूं (बिल्कुल उसी हेडर फ़ाइल में)। मुझे बस उस तरह से पढ़ने में आसान लगता है। खैर, मैं ऐसे मामले में आया हूं जहां मैं कक्षा के बाहर की परिभाषा में उपयोग करने के लिए एक कामकाजी प्रकार हस्ताक्षर नहीं समझ सकता। यहाँ मैं क्या कर रहा हूं की एक सरल उदाहरण है, कि समस्या दिखाता है:

template <class T> 
struct Foo 
    { 
    Foo(T a, T b); 

    template 
     < class Iterator 
     , enable_if< is_iterator<Iterator> > 
     > 
    Foo 
     (Iterator first 
     , Iterator last 
    ); 
    }; 

template <class T> 
Foo<T>::Foo(T a, T b) 
{ ... } 

template <class T> 
template 
    < class U 
    , WHAT_GOES_HERE? 
    > 
Foo<T>::Foo(U f, U l) 
{ ... } 

मैं उससे मिलते-जुलते हस्ताक्षर प्राप्त करने की कोशिश करने के लिए WHAT_GOES_HERE स्लॉट में चीजों के एक नंबर की कोशिश की है, और मैं बार-बार विफल। मुझे उस मामले को अलग करने के लिए enable_if की आवश्यकता है जहां कोई टाइप टी के दो ऑब्जेक्ट्स में गुजरता है, और जब कोई इटरेटर की एक जोड़ी में गुजरता है। कोड टेम्पलेट कन्स्ट्रक्टर को मुख्य टेम्पलेट के अंदर परिभाषित किया गया है, तो कोड ठीक काम करता है, इस प्रकार कोड वर्तमान में यह कैसे करता है, लेकिन मैं घोषणा के बाहर परिभाषा को अधिक स्थानांतरित करता हूं।

संपादित करें: मैं, < enable_if उल्लेख करना चाहिए कि मैं सिर्फ नहीं कर सकते फिर से उपयोग ...> परिभाषा क्योंकि enable_if < ...> अपने प्रकार है, जो आप में ऐसा नहीं कर सकते के लिए एक डिफ़ॉल्ट मान प्रदान करती है एक परिभाषा जो एक घोषणा भी नहीं है।

Answer 1

मैं ऐसा नहीं करता। यहां उन परिवर्तनों मैं होगा है:

template <class T> 
struct Foo 
    { 
    Foo(T a, T b); 

    template 
     < class Iterator 
     > 
    Foo 
     (Iterator first 
     , Iterator last 
     , typename enable_if<is_iterator<Iterator> >::type* = 0 
    ); 
    }; 

template <class T> 
Foo<T>::Foo(T a, T b) 
{ ... } 

template <class T> 
template 
    < class U 
    > 
Foo<T>::Foo(U f, U l, typename enable_if< is_iterator<U> >::type*) 
{ ... } 

यह सीधे enable_if के लिए दस्तावेज़ से बाहर है।

Answer 2

क्या आप इसे पूरा करने की कोशिश कर रहे हैं? [मेरे पास is_iterator टाइप विशेषता नहीं है, इसलिए मैंने सी ++ 0x प्रकार के गुणों और उपयोगिता पुस्तकालयों का उपयोग करके अपना उदाहरण दोबारा बनाया है। इसे TR1 और बूस्ट लाइब्रेरीज़ के साथ उसी तरह काम करना चाहिए।]

#include <utility> 
#include <type_traits> 

template <typename T> 
struct S 
{ 
    // Constructor (1) 
    S(T, T); 

    // Constructor (2) 
    template <typename U> 
    S(U, U, typename std::enable_if<std::is_integral<U>::value>::type* = 0); 
}; 

template <typename T> 
S<T>::S(T, T) 
{ } 

template <typename T> 
template <typename U> 
S<T>::S(U, U, typename std::enable_if<std::is_integral<U>::value>::type*) 
{ } 

int main() 
{ 
    S<double> a(1.0, 2.0); // uses (1) 
    S<double> b(1, 2);  // uses (2) 
} 

Answer 3

सरलतम आप क्या कर सकते हैं:

template<class Iterator> 
Foo 
    (Iterator first 
    , typename enable_if<is_iterator<Iterator>, Iterator>::type last 
); 

Answer 4

template <class T> 
struct Foo 
    { 
    Foo(T a, T b); 

    template <class Iterator 
     ,  class = typename std::enable_if 
         <is_iterator<Iterator>::value> 
         ::type 
     > 
    Foo 
     (Iterator first 
     , Iterator last 
    ); 
    }; 

template <class T> 
Foo<T>::Foo(T a, T b) 
{ } 

template <class T> 
template 
    < class U 
    , class > 
Foo<T>::Foo(U f, U l) 
{ }