टेम्पलेट क्लास सदस्य विशेषज्ञता की घोषणा

Question

जब मैं एक टेम्पलेट वर्ग में एक (स्थिर) सदस्य फ़ंक्शन/स्थिरता का विशेषज्ञ हूं, तो मैं इस बात से उलझन में हूं कि घोषणा कहां है।

यहाँ मैं क्या क्या करना है, इसका एक उदाहरण - IBM's reference on template specialization से सीधे yoinked:

=== आईबीएम सदस्य विशेषज्ञता उदाहरण ===

template<class T> class X { 
public: 
    static T v; 
    static void f(T); 
}; 

template<class T> T X<T>::v = 0; 
template<class T> void X<T>::f(T arg) { v = arg; } 

template<> char* X<char*>::v = "Hello"; 
template<> void X<float>::f(float arg) { v = arg * 2; } 

int main() { 
    X<char*> a, b; 
    X<float> c; 
    c.f(10); // X<float>::v now set to 20 
} 

सवाल यह है कि, मैं कैसे इस में विभाजित है हेडर/सीपीपी फाइलें? सामान्य कार्यान्वयन स्पष्ट रूप से शीर्षलेख में है, लेकिन विशेषज्ञता के बारे में क्या है?

यह हेडर फ़ाइल में नहीं जा सकता है, क्योंकि यह ठोस है, जिससे कई परिभाषाएं होती हैं। लेकिन अगर यह .cpp फ़ाइल में जाता है, तो वह कोड है जो एक्स :: एफ() को विशेषज्ञता के बारे में जानता है, या यह सामान्य एक्स :: एफ() पर भरोसा कर सकता है?

अब तक मुझे केवल .cpp में विशेषज्ञता प्राप्त हुई है, जिसमें शीर्षलेख में कोई घोषणा नहीं है। मुझे संकलन या यहां तक ​​कि मेरे कोड को चलाने में समस्या नहीं है (जीसीसी पर, इस समय संस्करण को याद न करें), और यह अपेक्षित व्यवहार करता है - विशेषज्ञता को पहचानना। लेकिन ए) मुझे यकीन नहीं है कि यह सही है, और मैं जानना चाहता हूं कि क्या है, और बी) मेरे डॉक्सिजन दस्तावेज भयानक और बहुत भ्रामक हैं (उस पर में एक पल बाद में एक प्रश्न)।

क्या, कुछ इस तरह होगा मेरे लिए सबसे प्राकृतिक लगता है शीर्षक में विशेषज्ञता की घोषणा और सीपीपी में यह परिभाषित करने:

=== XClass.hpp ===

#ifndef XCLASS_HPP 
#define XCLASS_HPP 

template<class T> class X { 
public: 
    static T v; 
    static void f(T); 
}; 

template<class T> T X<T>::v = 0; 
template<class T> void X<T>::f(T arg) { v = arg; } 

/* declaration of specialized functions */ 
template<> char* X<char*>::v; 
template<> void X<float>::f(float arg); 

#endif 

=== XClass.cpp ===

#include <XClass.hpp> 

/* concrete implementation of specialized functions */ 
template<> char* X<char*>::v = "Hello"; 
template<> void X<float>::f(float arg) { v = arg * 2; } 

... लेकिन मैं अगर यह सही है पता नहीं है। कोई विचार?

Answer 1

आमतौर पर आप हेडर में विशेषज्ञता inline को परिभाषित करेंगे जैसे कि डर्कगेट ने कहा था।

// x.h: 
template<class T> struct X { 
    void f() {} 
} 

// declare specialization X<int>::f() to exist somewhere: 
template<> void X<int>::f(); 

---

// translation unit with definition for X<int>::f(): 
#include "x.h" 
template<> void X<int>::f() { 
    // ... 
} 

तो हाँ, अपने दृष्टिकोण ठीक लग रहा है:

आप हालांकि अगर आप संकलन बार या कोड ब्लोट को लेकर चिंतित हैं अलग अनुवाद इकाइयों में विशेषज्ञता परिभाषित कर सकते हैं। ध्यान दें कि आप केवल पूर्ण विशेषज्ञता के साथ ऐसा कर सकते हैं, इस प्रकार यह अक्सर ऐसा करने के लिए अव्यवहारिक होता है।

विवरण के लिए, उदा। देखें Comeaus template FAQ।

Answer 2

उन्हें सभी को hpp फ़ाइल में रखें। कक्षा inline के बाहर परिभाषित विशेषज्ञता और कुछ भी बनाएं - जो कई परिभाषाओं का ख्याल रखेगा।

Answer 3

अपने प्रश्न का उत्तर करने के लिए: संकलक एक परिभाषा है जो अपनी आवश्यकताओं से मेल खाता देखता is code which calls X::f() aware of the specialization, or might it rely on the generic X::f()?

है, तो यह इसका इस्तेमाल होगा। अन्यथा यह सामान्य फ़ंक्शन कॉल उत्पन्न करेगा।

अपने पहले कोड स्निपेट में, आप X<T>::f(T arg) के लिए एक सामान्य परिभाषा की आपूर्ति, इसलिए संकलक float से अलग किसी भी T के लिए दृष्टांत होगा।

यदि आप जेनेरिक परिभाषा को छोड़ना चाहते हैं, तो संकलक X<double>::f(double) कहने के लिए कॉल उत्पन्न करेगा और लिंकर परिभाषा की खोज करेगा जो एक लिंकर त्रुटि के साथ समाप्त हो सकता है।

संक्षेप में: आपके पास हेडर में सबकुछ हो सकता है, क्योंकि टेम्पलेट्स के रूप में आपको कई परिभाषाएं नहीं मिलेंगी। यदि आपके पास केवल घोषणाएं हैं, तो आपको बाद में ढूंढने के लिए लिंकर के लिए कहीं और परिभाषाओं की आवश्यकता होगी।