आधार वर्ग के टेम्पलेट पैरामीटर के रूप में बाल वर्ग का उपयोग करना और घोंसला वाले नाम के रूप में

Question

मैं अपनी कक्षा का उपयोग अपने मूल वर्ग में से किसी एक के टेम्पलेट पैरामीटर के रूप में कर रहा हूं, और यह कि अभिभावक वर्ग इसे टेम्पलेट तर्क में उपयोग करता है (हालांकि आकार())।

और संकलक मुझे देता है:

त्रुटि: अधूरा प्रकार 'Invoker :: workerClass {उर्फ MyClass}' नेस्टेड नाम विनिर्देशक में इस्तेमाल

फिर भी वर्ग अच्छी तरह से फाइल में परिभाषित किया गया है । मुझे लगता है कि ऐसा इसलिए है क्योंकि बेस क्लास 'तत्कालता के पल में बाल वर्ग को तत्काल नहीं किया जाता है, फिर भी इस तरह की चीज CRTP के साथ होती है और इसमें कोई समस्या नहीं है।

टेम्पलेट तर्क में बाल वर्ग का उपयोग करने का कारण एक अलग फ़ंक्शन कॉल करना है यदि बच्चे वर्ग के पास एक विशिष्ट कार्य है, या नहीं है।

यहाँ के परीक्षण के लिए एक न्यूनतम कोड है

/* Structure similar to boost's enable if, to use 
    SFINAE */ 
template <int X=0, class U = void> 
struct test { 
    typedef U type; 
}; 

enum Commands { 
    Swim, 
    Fly 
}; 

/* Structure used for template overloading, 
    as no partial function template specialization available */ 
template<Commands T> 
struct Param { 

}; 

template <class T> 
class Invoker 
{ 
public: 
    typedef T workerClass; 

    workerClass *wc() { 
     return static_cast<workerClass*>(this); 
    } 

    template <Commands command> 
    void invoke() { 
     invoke2(Param<command>()); 
    } 

    /* If the child class has those functions, call them */ 
    /* Needs template paramter Y to apply SFINAE */ 
    template<class Y=int> 
    typename test<sizeof(Y)+sizeof(decltype(&workerClass::fly))>::type 
    invoke2(Param<Fly>) { 
     wc()->fly(); 
    } 

    template<class Y=int> 
    typename test<sizeof(Y)+sizeof(decltype(&workerClass::swim))>::type 
    invoke2(Param<Swim>) { 
     wc()->shoot(); 
    } 

    template<Commands command> 
    void invoke2(Param<command>) { 
     /* Default action */ 
     printf("Default handler for command %d\n", command); 
    } 
}; 

template <class T, class Inv = Invoker<T> > 
class BaseClass : public Inv 
{ 
public: 
    template<Commands command> 
    void invoke() { 
     Inv::template invoke<command>(); 
    } 
}; 

class MyClass : public BaseClass<MyClass> 
{ 
public: 
    void swim() { 
     printf("Swimming like a fish!\n"); 
    } 

    /* void fly(); */ 
}; 


void testing() { 
    MyClass foo; 
    foo.invoke<Fly>(); /* No 'void fly()' in MyClass, calls the default handler */ 
    foo.invoke<Swim>(); /* Should print the swimming message */ 
} 

त्रुटि पंक्ति होता है:

typename test<sizeof(Y)+sizeof(decltype(&workerClass::fly))>::type 

तो, वहाँ किसी भी संकलक है कि इस का समर्थन करता है, या इस पर स्पष्ट रूप के रूप में मानक द्वारा निर्दिष्ट किया जाता टेम्पलेट्स का अमान्य उपयोग? क्या मुझे ऐसा करने के तरीके को बदलना है और चारों ओर एक रास्ता खोजना है? सीआरटीपी मुझे आशा दे रहा है कि कोड वैध हो सकता है, लेकिन मुझे यकीन नहीं है।

यदि यह वास्तव में संभव नहीं है, तो क्यों, और सीआरटीपी क्यों काम करता है?

Answer 1

समाधान, जैसा कि ildjarn ने इंगित किया था, संकेत का एक और स्तर जोड़ने के लिए।

परीक्षण समारोह को बदलने के प्रकारों को स्वीकार करने द्वारा किया जाता है यही कारण है कि:

template <typename X, class U = void> 
struct test { 
    typedef U type; 
}; 

और फिर बजाय से यह निर्दिष्ट करने के लिए, एक टेम्पलेट पैरामीटर के रूप में बच्चे को कक्षा पास कर जाना:

template<class Y=workerClass> 
    typename test<decltype(&Y::fly)>::type 
    invoke2(Param<Fly>) { 
     wc()->fly(); 
    } 

    template<class Y=workerClass> 
    typename test<decltype(&Y::swim)>::type 
    invoke2(Param<Swim>) { 
     wc()->swim(); 
    } 

इस तरह नेस्टेड विनिर्देशक का मूल्यांकन तब किया जाता है जब समारोह को कक्षा मूल्यांकन में बुलाया जाता है, और उस समय तक बाल वर्ग का मूल्यांकन पहले ही किया जाता है। इसके अलावा डिफ़ॉल्ट टेम्पलेट तर्क को पारित करने की संभावना के साथ, हम बिना किसी टेम्पलेट पैरामीटर के फ़ंक्शन को कॉल कर सकते हैं।

टेम्पलेट अब भी और अधिक पठनीय है। और नमूना कोड अब बस ठीक काम करता है:

class MyClass : public BaseClass<MyClass> 
{ 
public: 
    void swim() { 
     printf("Swimming like a fish!\n"); 
    } 

    /* void fly(); */ 
}; 


void testing() { 
    MyClass foo; 
    foo.invoke<Fly>(); /* No 'void fly()' in MyClass, calls the default handler */ 
    foo.invoke<Swim>(); /* Should print the swimming message */ 
}