वैश्विक ऑपरेटर की जांच के लिए SFINAE का उपयोग <<?

Question

मैं कई अधिभारित करना चाहता हूं, वैश्विक to_string() फ़ंक्शंस जो कुछ प्रकार T लेते हैं और इसे अपने स्ट्रिंग प्रस्तुति में परिवर्तित करते हैं। सामान्य मामले के लिए, मैं लिखने के लिए सक्षम होना चाहते हैं:

template<typename T,class OutputStringType> inline 
typename enable_if<!std::is_pointer<T>::value 
       && has_insertion_operator<T>::value, 
        void>::type 
to_string(T const &t, OutputStringType *out) { 
    std::ostringstream o; 
    o << t; 
    *out = o.str(); 
} 

has_insertion_operator मेरे कार्यान्वयन अब तक है:

struct sfinae_base { 
    typedef char yes[1]; 
    typedef char no[2]; 
}; 

template<typename T> 
struct has_insertion_operator : sfinae_base { 
    template<typename U> static yes& test(U&); 
    template<typename U> static no& test(...); 

    static std::ostream &s; 
    static T const &t; 

    static bool const value = sizeof(test(s << t)) == sizeof(yes); // line 48 
}; 

(यह this और this से उधार लेता है।) काम करने के लिए लगता है कि । लेकिन अब मैं ऐसा नहींoperator<< लेकिन करना अपने स्वयं के to_string()सदस्य कार्य हो है प्रकार, अर्थात् के लिए to_string का एक अतिभारित संस्करण करना चाहते हैं:

template<class T,class OutputStringType> inline 
typename enable_if<!has_insertion_operator<T>::value 
       && has_to_string<T,std::string (T::*)() const>::value, 
        void>::type 
to_string(T const &t, OutputStringType *out) { 
    *out = t.to_string(); 
} 

has_to_string के कार्यान्वयन है:

#define DECL_HAS_MEM_FN(FN_NAME)          \ 
    template<typename T,typename S>          \ 
    struct has_##FN_NAME : sfinae_base {        \ 
    template<typename SignatureType,SignatureType> struct type_check; \ 
    template<class U> static yes& test(type_check<S,&U::FN_NAME>*); \ 
    template<class U> static no& test(...);       \ 
    static bool const value = sizeof(test<T>(0)) == sizeof(yes); \ 
    } 

DECL_HAS_MEM_FN(to_string); 

(यह हिस्सा ठीक काम करता प्रतीत होता है। इसे this से अनुकूलित किया गया है।) हालांकि, मैं जब:

struct S { 
    string to_string() const { 
    return "42"; 
    } 
}; 

int main() { 
    string buf; 
    S s; 
    to_string(s, &buf); // line 104 
} 

मैं:

foo.cpp: In instantiation of ‘const bool has_insertion_operator<S>::value’: 
foo.cpp:104: instantiated from here 
foo.cpp:48: error: no match for ‘operator<<’ in ‘has_insertion_operator<S>::s << has_insertion_operator<S>::t’ 

ऐसा लगता है SFINAE की तरह हो रहा है। मैं has_insertion_operator को सही तरीके से कैसे लिखूं जैसे यह निर्धारित करता है कि वैश्विक operator<< उपलब्ध है या नहीं?

एफवाईआई: मैं जी ++ 4.2.1 (जो कि मैक ओएस एक्स पर एक्सकोड के हिस्से के रूप में जहाजों का उपयोग कर रहा है) का उपयोग कर रहा हूं। इसके अलावा, मैं कोड को केवल तृतीय-पक्ष पुस्तकालयों के बिना मानक सी ++ 03 होना चाहता हूं, उदाहरण के लिए, बूस्ट।

धन्यवाद!

Answer 1

मुझे this उत्तर के लिए बस अधिक वफादार होना चाहिए था। एक काम कर दिया गया है:

namespace has_insertion_operator_impl { 
    typedef char no; 
    typedef char yes[2]; 

    struct any_t { 
    template<typename T> any_t(T const&); 
    }; 

    no operator<<(std::ostream const&, any_t const&); 

    yes& test(std::ostream&); 
    no test(no); 

    template<typename T> 
    struct has_insertion_operator { 
    static std::ostream &s; 
    static T const &t; 
    static bool const value = sizeof(test(s << t)) == sizeof(yes); 
    }; 
} 

template<typename T> 
struct has_insertion_operator : 
    has_insertion_operator_impl::has_insertion_operator<T> { 
}; 

मेरा मानना ​​है कि यह नहीं वास्तव में SFINAE पर भरोसा करता है।

Answer 2

लाइन 48 पर value का प्रारंभकर्ता एक संदर्भ में नहीं है जहां SFINAE काम करता है। अभिव्यक्ति को फ़ंक्शन घोषणा में ले जाने का प्रयास करें।

#include <iostream> 

struct sfinae_base { 
    typedef char yes[1]; 
    typedef char no[2]; 
}; 

template<typename T> 
struct has_insertion_operator : sfinae_base { 

    // this may quietly fail: 
    template<typename U> static yes& test(
     size_t (*n)[ sizeof(std::cout << * static_cast<U*>(0)) ]); 

    // "..." provides fallback in case above fails 
    template<typename U> static no& test(...); 

    static bool const value = sizeof(test<T>(NULL)) == sizeof(yes); 
}; 

हालांकि, मुझे इसमें परिष्कार की मात्रा पर सवाल उठाना है। मैं गैर-ऑर्थोगोनल तंत्र देखता हूं जो एक दूसरे के खिलाफ पीसेंगे (to_string बनाम operator<<) और मुझे लगता है कि खराब धारणाएं फेंक रही हैं (उदाहरण के लिए operator<< वैश्विक बनाम सदस्य है, हालांकि लागू कोड को उस संबंध में ठीक दिखता है)।