कैसे जांचें कि किसी वर्ग ने नेस्टेड क्लास परिभाषा या सी ++ 11 में टाइपपीफ निर्दिष्ट किया है या नहीं?

Question

मेरी प्रोजेक्ट में, मैं कुछ मौजूदा बड़ी कक्षाओं के टेम्पलेट प्रॉक्सी क्लास को कार्यान्वित करना चाहता हूं। मौजूदा वर्ग लाइब्रेरी कक्षाएं हैं, इसलिए उन्हें संशोधित नहीं किया जा सकता है। ज्यादातर मामलों में, ग्राहकों को पता नहीं है कि वस्तुओं प्रॉक्सी वर्ग या बड़ी कक्षा के उदाहरण हैं। कुछ मामलों में, हालांकि, ग्राहकों को विस्तृत कक्षा की जानकारी जाननी चाहिए। चूंकि प्रॉक्सी क्लास स्वयं टेम्पलेट क्लास है, इसलिए मुझे नहीं लगता कि क्लास नाम से सरल फ़ंक्शन ओवरलोडिंग इस समस्या को हल कर सकती है। संभावित समाधान मैंने सोचा कि प्रॉक्सी क्लास के अंदर एक आंतरिक नेस्टेड क्लास या टाइपपीफ जोड़ना है, और क्लाइंट यह जांचता है कि क्लास की जानकारी प्राप्त करने के लिए यह क्लास/टाइपपीफ मौजूद है या नहीं। मेरा सवाल है: कैसे जांचें कि किसी वर्ग ने नेस्टेड क्लास परिभाषा या सी ++ 11 में टाइपपीफ निर्दिष्ट किया है या नहीं?

#include <iostream> 
#include <functional> 
#include <string> 
#include <vector> 
#include <type_traits> 

typedef std::string CBig1; // use string for demonstration 
typedef std::string CBig2; // use string for demonstration 

//class CBig1; // the bigger class 1, codes of which can not be changed 
//class CBig2; // the bigger class 2, codes of which can not be changed 

template <typename _Big, typename _Other> 
class CProxy 
{ 
public: 
    struct proxy_tag { }; 
}; 

// how to implement this ? 
// the proxy traits class, if defined _T::proxy_tag, the ``type'' will be std::true_type, otherwise the ``type'' will be std::false_type 
template <typename _T> 
struct is_proxy 
{ 
    //typedef std::true_type type; 
    //typedef std::false_type type; 
}; 

template <typename _T> 
void ClientHelp(const _T& t, std::false_type) 
{ 
    // process real class 
    std::cerr << "real class" << std::endl; 
} 

template <typename _T> 
void ClientHelp(const _T& t, std::true_type) 
{ 
    // process proxy class 
    std::cerr << "proxy class" << std::endl; 
} 

template <typename _T> 
void Client(const _T& t) 
{ 
    ClientHelp(t, typename is_proxy<_T>::type()); 
} 

int main(int argc, char* argv[]) 
{ 
    CBig1 b; 
    CProxy<CBig1, int> p; 
    Client(b); 
    Client(p); 
    return 0; 
} 

कैसे लक्षण वर्ग is_proxy लागू करने के लिए:

निम्नलिखित कोड का एक उदाहरण दिखाते हैं?

Answer 1

सी ++ 11 में सी ++ 03 संस्करण के लिए एक पूरक, आप decltype मिल के रूप में:

template <typename T> 
auto is_proxy(T const&) -> decltype(T::proxy_tag{}, std::true_type{}) { 
    return std::true_type{}; 
} 

std::false_type is_proxy(...) { return std::false_type{}; } 

और Client अपने क्रियान्वयन हो जाता है:

template <typename T> 
void Client(T const& t) { 
    ClientHelp(t, is_proxy(t)); 
} 

मीठा, नहीं है यह

Answer 2

आप एक वर्ग एक प्रॉक्सी बनाने के लिए हल्के प्रकार वर्गीकरण मुहावरा

template<class T, class R = void> 
struct enable_if_type { typedef R type; }; 

template<class T, class Enable = void> 
struct test : std::false_type {}; 

template<class T> 
struct test<T, typename enable_if_type<typename T::is_proxy_tag>::type> : std::true_type 
{}; 

template <typename _Big, typename _Other> 
class CProxy 
{ 
    public: 
    typedef void is_proxy_tag; 
}; 

तो उपयोग कर सकते हैं तो बस इस

typedef void is_proxy_tag; 

और enable_if_type में SFINAE जोड़ने उचित true_type/false_type विशेषज्ञता का चयन करेंगे

ध्यान दें किके बजाय boost::mpl::true_ का उपयोग करनाआदि इस समाधान को सी ++ 03 के लिए काम करता है।