टेम्पलेट वर्ग के सीआरटीपी उप-वर्गों की संख्या को कैसे गिनें?

Question

क्या किसी को ऑब्जेक्ट के उप-वर्गों की संख्या गिनने के लिए सीआरटीपी का उपयोग करने के तरीके की जानकारी है?

मान लीजिए हम एक सेटअप करने के लिए इसी तरह की एक निम्नलिखित था:

template <typename T>  
class Object 
{ 
    .... 
}; 

const unsigned int ObjectSubClassCount = ...; 

class Subobject : public Object<SubObject> 
{ 
    .... 
}; 

class Second : public Object<Second> 
{ 
    .... 
}; 

और इतने पर, ऐसा है कि, TMP का उपयोग कर, हम हो सकता है एक निरंतर (ObjectSubClassCount) कि उपवर्गों की कुल संख्या का प्रतिनिधित्व करता है?

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

संपादित करें: मैं बाद में मैं करूंगा टेम्पलेट पैरामीटर के रूप में परिणाम का उपयोग करने के बाद टेम्पलेट पैरामीटर के रूप में परिणाम का उपयोग करना चाहते हूँ, इसलिए मैं यह TMP के साथ किया जा करने की जरूरत है ...

Answer 1

आवश्यकता के बिना ऐसा करने की कोशिश करें:

// Class which increments a given counter at instanciation 
struct Increment { 
    Increment(std::size_t& counter) 
    { 
    counter++; 
    } 
}; 

// This is your template base 
template <typename T>  
class Object 
{ 
    private: 
    // For every instanciation of the template (which is done for a subclass) 
    // the class counter should get incremented 
    static Increment incrementCounter; 
}; 

// This is the global object counter 
static std::size_t classCounter; 

// Static Member Variable 
template<typename T> 
Object<T>::incrementCounter(classCounter); 

इसे आजमाया नहीं है लेकिन करना चाहिए। परिणाम फिर से टेम्पलेट पैरामीटर के रूप में उपलब्ध कराने के लिए (एमपीएल) मेरे पास एमपीएल में पर्याप्त अनुभव नहीं है लेकिन मुझे संदेह है कि यह संभव है।

Answer 2

ठीक है, इसलिए मैं ... कुछ हद तक स्वीकार्य उत्तर पर आया हूं। मुझे लगा कि उप-वर्गों को बिल्कुल एक दूसरे का ज्ञान नहीं था (मेरा मतलब है, हम कुछ हद तक कार्यात्मक प्रोग्रामिंग कर रहे हैं ...)।

यहां इसके लिए एक समाधान है। यह निश्चित रूप से समाधान नहीं है जिसे मैं चाहता हूं; हालांकि, यह एक शुरुआत है। मैंने सभी ऑब्जेक्ट्स को सीआरटीपी के रूप में उपयोग करने के लिए मजबूर कर दिया है, लेकिन एक जो एक लिंक किए गए सूची प्रारूप का अधिक उपयोग करता है।

एक:: ही और बी: सबसे हाल ही में पहले से परिभाषित उपवर्ग

यहाँ

इस के लिए मेरे कोड (मैं से एक टेम्पलेट का उपयोग है इस तरह, हमारे उपवर्गों> से टेम्प्लेट की एक वस्तु < से प्राप्त किया जाना चाहिए , एक बार <type_traits> सिर्फ एक नोट)

template <typename T> //SFINAE check for the existance of subclasscount static member 
struct has_subclasscount 
{ 

    template <typename U> 
    static typename std::enable_if<sizeof(U::subclasscount) != 0, int>::type test(int); 

    template <typename U> 
    static char test(...); 

    static const bool result = (sizeof(test<T>(0)) == sizeof(int))?(true):(false); 
}; 


template <bool res, typename T> 
struct return_subclasscount //the value to return is 0 if false 
{ 
    static const int result = 0; 
}; 


template <typename T>  
struct return_subclasscount<true, T> //returns subclasscount only if the first parameter is true 
{ 
    static const int result = T::subclasscount; 
}; 


template <typename T>    //combines return_subclasscount and has_subclasscount 
struct get_subclasscount 
{ 
    static const int result = return_subclasscount<has_subclasscount<T>::result, T>::result; 
}; 


template <typename This, typename Prev> 
class Object 
{ 
public: 

    static const int subclasscount = 1 + get_subclasscount<Prev>::result; //the subclass count 
}; 


class sub1 : public Object<sub1, int> 
{ 

}; 


class sub2 : public Object<sub2, sub1> 
{ 

}; 


class sub3 : public Object<sub3, sub2> 
{ 

}; 

ये पिछले 3 खाली कक्षाओं उपवर्गों कि हम गिनती कर रहे हैं कर रहे हैं। यह हमारी हेडर फ़ाइल है। हमारे मुख्य .cpp फ़ाइल में, हम है:

कौन सा पुष्टि की है कि यह काम किया है:

int main() { 

std::cout << sub3::subclasscount; 

char c; 
std::cin >> c; 
} 

यह चल रहा है, हम का एक सरल उत्पादन मिलता है। अब, यह समाधान के लिए कमियां में से कुछ है:

• हम पता होना चाहिए कि हमारे पिछले परिभाषित उपवर्ग था इससे पहले कि हम पर जोड़ें।
• हमें कहीं भी साथ रहना चाहिए, हम सबक्लास काउंटर का उपयोग करते हैं, हमेशा इसे सूची में अंतिम उप-वर्ग से संशोधित करते हैं (इसे एक सतत "एंडोफलिस्ट" सबक्लास का उपयोग करके बदला जा सकता है, जिसे इसके बजाय बनाए रखने की आवश्यकता होगी)

उपरोक्त, इस तथ्य को शामिल करते हैं कि हमें हमारे पहले परिभाषित उप-वर्गों में से किसी को भी बनाए रखने की आवश्यकता नहीं है।हालांकि, मैं इस जवाब को "अंतिम समाधान" की तुलना में "शुरुआती बिंदु" के बारे में अधिक मानता हूं; शायद कुछ ऐसा किया जा सकता है जिस पर विस्तार किया जा सकता है?

किसी को भी यहां से कोई विचार है (यह भी, यह आसानी से वृक्ष संरचना, जहां subclasscount वास्तव में पेड़ में किसी भी नोड की गहराई का प्रतिनिधित्व करते हैं का एक रूप बनाने के लिए दुरुपयोग किया जा सकता है)?