टाइप गुण विशेषज्ञता

Question

template<typename T> 
class vec3 
{ 
public: 
    typename T type_t; 
    T x; 
    T y; 
    T z; 
}; 

template<typename T> 
struct numeric_type_traits_basic_c 
{ 
    typedef T type_t; 
    typedef T scalar_t; 
}; 

template<typename T> 
struct numeric_type_traits_vec3_c 
{ 
    typedef T type_t; 
    typedef typename T::type_t scalar_t; 
}; 

typedef numeric_type_traits_basic_c<int> int_type_traits; 
typedef numeric_type_traits_vec3_c< vec3<int> > vec3_int_type_traits; 

यह स्केलर और वेक्टर के लिए प्रकार का गुण है, केवल अंतर यह है कि एक वेक्टर के लिए स्केलर प्रकार, इसके तत्व का प्रकार है। ठीक काम करता है।

लेकिन मैं वास्तव में उन दो वर्गों के लिए एक ही नाम का उपयोग करने में सक्षम होना चाहता हूं।

template<typename T> 
struct numeric_type_traits_c 
{ 
    typedef T type_t; 
    typedef ????? scalar_t; 
}; 

मैं जानता हूँ कि यह अगर वर्ग प्रत्येक प्रकार मैं जरूरत के लिए स्पष्ट रूप से विशेष है ऐसा करने के लिए संभव है: int, नाव, vec3, vec3 ...

दोहराव के लिए बहुत कुछ है यही कारण है कि ... कैसे क्या मैं कोड के पहले बिट की सादगी रख सकता हूं लेकिन एक ही कक्षा का नाम एक ही समय में हो सकता है?

Answer 1

यह आंशिक वर्ग टेम्पलेट विशेषज्ञता के लिए वाक्यविन्यास है 'टाइप फंक्शन' पॉलिमॉर्फिज्म।

आप इस समारोह च तुलना:

struct I { virtual double f()const = 0; }; // C++ version of 'an interface' 
struct A : public I { virtual double f()const{ return 0; } }; 
struct B : public I { virtual double f()const{ return 1; } }; 
struct C { }; 

void f(const I& i){ return I.f(); } 

f(A()); 
f(C()); // compiler warning: wrong type provided. 

इस समारोह च के साथ

:

// struct TI { typedef ??? iT; }; // no C++ version of a type-interface 
struct TA { typedef int iT; }; 
struct TB { typedef double iT; }; 
struct TC { }; 

template< typename aTI > struct fT { typedef aTI::iT returnType; }; 

fT<TA>::returnType vA; 
ft<C>::returnType vC; // compiler error: C has no iT member. 

आप देखते हैं कि फर्क सिर्फ इतना है मापदंडों के अंकन है। पहला कार्य एक 'नियमित' बहुरूप कार्य है। संकलक हमें चेतावनी देगा अगर प्रदत्त तर्क उचित प्रकार का नहीं है।

एफटी एक ऐसा कार्य है जिसे केवल एक निश्चित प्रकार निर्धारित करने के लिए कंपाइलर द्वारा उपयोग किया जा सकता है। यह तर्क के रूप में एक प्रकार लेता है। लेकिन भाषा में एक प्रकार की बाधा का कोई "अवधारणा" नहीं है (अभी तक - सी ++ 0x में अवधारणाएं देखें)। इसलिए हमें यह गारंटी देने की ज़रूरत है कि हम टाइप प्रकार के 'इंटरफ़ेस' को सही इंटरफ़ेस के लिए उपयोग करते हैं।

कंक्रीटो में, यह scalar_t को numeric_type_traits_c प्रकार फ़ंक्शन के साथ उपयोग करने के लिए किसी भी कक्षा में टाइप करने के लिए उबलता है।

Answer 2

शायद आपको अपने टेम्पलेट को दो प्रकार से तुरंत चालू करना चाहिए? देखें:

template<typename TYPE, typename SCALAR> 
struct numeric_type_traits_c 
{ 
    typedef TYPE type_t; 
    typedef SCALAR scalar_t; 
}; 

typedef numeric_type_traits_c<int,int> int_type_traits; 
typedef numeric_type_traits_c<vec3<int>, vec3<int>::type_t> vec3_type_traits; 

Answer 3

template<typename T> 
struct numeric_type_traits_c 
{ 
     typedef T type_t; 
     typedef T scalar_t; 
}; 

template<typename T> 
struct numeric_type_traits_c<vec3<T> > 
{ 
     typedef vec3<T> type_t; 
     typedef typename vec3<T>::type_t scalar_t; 
}; 

हाँ, निश्चित रूप से मैं एक गलती type_t में vec3 के लिए बना दिया है!

template<typename T> 
struct numeric_type_traits // basic template 
{ 
    typedef T type_t; 
    typedef T scalar_t; 
}; 

template<typename T> 
struct numeric_type_traits< vec3<T> > // partial specialisation for vec3's 
{ 
    typedef vec3<T> type_t; 
    typedef T scalar_t; 
}; 

और इसी तरह, जैसे::

template <typename T, typename T_Alloc> 
struct numeric_type_traits< std::vector<T,T_Alloc> > // part. spec. for std::vector 
{ 
    typedef std::vector<T,T_Alloc> type_t; // deal with custom allocators, too 
    typedef T scalar_t; 
}; 

Answer 4

एक दिलचस्प टिप्पणी यहाँ ज्ञान हम करने के लिए गतिशील बहुरूपता से है को लागू करने में निहित है