वर्ग

Question

के अंदर और बाहर परिभाषित टेम्पलेट वर्ग के लिए सदस्य फ़ंक्शंस के बीच अंतर क्या वर्ग घोषणा के अंदर टेम्पलेट क्लास के लिए सदस्य फ़ंक्शंस को परिभाषित करने के बीच कोई अंतर है?

अंदर निर्धारित:

template <typename T> 
class A 
{ 
public: 
    void method() 
    { 
     //... 
    } 
}; 

बाहर निर्धारित:

template <typename T> 
class B 
{ 
public: 
    void method(); 
}; 

template <typename T> 
void B<T>::method() 
{ 
    //... 
} 

गैर टेम्पलेट वर्गों के लिए, यह inlined और गैर inlined विधियों के बीच अंतर है। क्या यह टेम्पलेट कक्षाओं के लिए भी सच है?

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

संपादित करें: कृपया मान लें कि उपर्युक्त कोड कक्षा के लिए शीर्षलेख फ़ाइल में प्रदान किया गया है।

Answer 1

हां, टेम्पलेट कक्षाओं के लिए बिल्कुल सही है।

कारण टेम्पलेट कक्षाओं के लिए विधि परिभाषाओं को आम तौर पर इनलाइन होना पसंद किया जाता है यह है कि टेम्पलेट्स के साथ, टेम्पलेट को तत्काल होने पर पूरी परिभाषा दिखाई देनी चाहिए।

तो यदि आप कुछ अलग .cpp फ़ाइल में फ़ंक्शन परिभाषा डालते हैं, तो आपको एक लिंकर त्रुटि मिल जाएगी। एकमात्र सामान्य समाधान फ़ंक्शन इनलाइन को या तो कक्षा के अंदर या inline कीवर्ड के साथ परिभाषित करके करना है। लेकिन किसी भी मामले में, इसे कहीं भी फ़ंक्शन कहा जाता है, जिसका अर्थ है कि यह आमतौर पर वर्ग परिभाषा के समान ही शीर्षलेख में होना चाहिए।

Answer 2

अधिक टाइप करने के अलावा, कोई अंतर नहीं है। इसमें template बिट, inline शामिल है और कक्षा का जिक्र करते समय अधिक "विस्तृत" नामों का उपयोग करना पड़ता है। उदाहरण

template <typename T> class A { 
    A method(A a) { 
    // whatever 
    } 
}; 

template <typename T> inline A<T> A<T>::method(A a) { 
    // whatever 
} 

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

Answer 3

मुझे यह पता है..मुझे लगता है कि यह कुछ होना चाहिए जो आपको पूरा करने में मदद करता है?

// This might be in a header file: 
template <typename T> 
class xyz { 
    void foo(); 
    }; 

// ...

// This might be later on in the header file: 
    void xyz<T>::foo() { 
// generic definition of foo() 
    } 

यह एक के लिए गलत है:

defining a member function outside of its template 

यह इस तरह एक टेम्पलेट वर्ग के एक सदस्य समारोह की परिभाषा प्रदान करने के लिए ठीक नहीं है कुछ कारण तो यह है:

 void xyz<class T>::foo() { 
     // generic definition of foo() 
     } 

उचित परिभाषा टेम्पलेट कीवर्ड और एक ही टेम्पलेट तर्क वर्ग खाके की परिभाषा के साथ घोषित किया गया था की जरूरत है।ताकि देता है:

 template <typename T> 
      void xyz<T>::foo() { 
      // generic definition of foo() 
       } 

नोट इस तरह के सदस्य टेम्पलेट्स, आदि के रूप में टेम्पलेट निर्देशों के अन्य प्रकार, हैं कि, और प्रत्येक अपने स्वयं के प्रारूप पर ले जाता है। यह जानना महत्वपूर्ण है कि आपके पास कौन सा है, इसलिए आप जानते हैं कि प्रत्येक स्वाद को कैसे लिखना है। यह इसलिए विशेष रूप से है क्योंकि कुछ कंपाइलरों के त्रुटि संदेश गलत नहीं होने के कारण स्पष्ट नहीं हो सकते हैं। और निश्चित रूप से, एक अच्छी और अद्यतित किताब प्राप्त करें।

आप किसी टेम्पलेट के भीतर एक नेस्टेड सदस्य टेम्पलेट है, तो:

template <typename T> 
     struct xyz { 
     // ... 
     template <typename U> 
     struct abc; 
     // ... 
     }; 

कैसे आपने xyz के बाहर एबीसी परिभाषित करते हैं? यह काम नहीं करता:

 template <typename U> 
    struct xyz::abc<U> { // Nope 
     // ... 
    }; 

है और न ही ऐसा करता है:

template <typename T, typename U> 
struct xyz<T>::abc<U> { // Nope 
// ... 
}; 

आप ऐसा करने के लिए होगा:

 template <typename T> 
     template <typename U> 
      struct xyz<T>::abc { 
      // ... 
      }; 

ध्यान दें कि यह ...abc नहीं ...abc<U> है क्योंकि एबीसी एक "प्राथमिक" है टेम्पलेट। आईओएस, यह अच्छा नहीं है:

// यहां अनुमति नहीं है: टेम्पलेट टेम्पलेट संरचना xyz :: abc {};