सी ++ में एक सरणी के लिए ऑपरेटर << कैसे अधिभार?

Question

मैं इसे इस तरह से करने की कोशिश कर रहा हूं:

template <typename T> 
ostream &operator<<(ostream &os, T &arr) 
{ /*...*/ } 

लेकिन T एक सरणी का प्रतिनिधित्व कर सकता है? क्या सरणी के लिए << ऑपरेटर को अधिभारित करना सही है?

---

संपादित करें:

केरेक एसबी की सलाह के अनुसार, यहां <<:

template <typename T, unsigned int N> 
ostream &operator<<(ostream &os, const T (&arr)[N]) 
{ 
    int i; 
    for(i = 0; i < N; i++) 
     os << arr[i] << " "; 
    os << endl; 
    return os; 
} 

के लिए मेरा कार्यान्वयन है क्या मेरा कार्यान्वयन सही है? मुझे एक संकलन त्रुटि मिली है।

Answer 1

आप ऐसा कर सकता है:

template <typename T, unsigned int N> 
std::ostream & operator<<(std::ostream & os, const T (&arr)[N]) 
{ 
    // .. 
    return os; 
} 

यह केवल संकलन समय सरणियों के लिए, निश्चित रूप से काम करता है। ध्यान दें कि T एक अंतर्निहित प्रकार या std नामस्थान में एक प्रकार है जब आपको इस टेम्पलेट को तुरंत चालू करने की अनुमति नहीं है!

संभवतः इस इनलाइन को संभव बनाने के लिए सबसे अच्छा है, क्योंकि आप प्रत्येक N के लिए एक अलग तत्कालता का कारण बनेंगे। के लिए अधिभार const char (&)[6] मिलान टेम्पलेट, और (गैर टेम्पलेट): (pretty printer इस का एक उदाहरण है।)

आप देखेंगे हालांकि, कि कंबल टेम्पलेट एक अस्पष्टता का परिचय है, क्योंकि os << "Hello" अब दो संभावित भार के है क्षय-से-सूचक const char *, दोनों के समान रूपांतरण अनुक्रम हैं।

template <typename T, unsigned int N, typename CTy, typename CTr> 
typename std::enable_if<!std::is_same<T, char>::value, 
         std::basic_ostream<CTy, CTr> &>::type 
operator<<(std::basic_ostream<CTy, CTr> & os, const T (&arr)[N]) 
{ 
    // .. 
    return os; 
} 

तथ्य यह है कि ध्यान में रखते हुए:

#include <ostream> 
#include <type_traits> 

template <typename T, unsigned int N> 
typename std::enable_if<!std::is_same<T, char>::value, std::ostream &>::type 
operator<<(std::ostream & os, const T (&arr)[N]) 
{ 
    // .. 
    return os; 
} 

वास्तव में, यहां तक ​​कि अधिक सामान्य आप भी basic_ostream मापदंडों टेम्प्लेट पैरामीटर कर सकते हैं होने के लिए: हम चार सरणियों के लिए हमारे अधिभार को अक्षम करके इस हल कर सकते हैं T एक उपयोगकर्ता परिभाषित प्रकार होना चाहिए, आप थोड़ा और जांच प्राप्त करने के लिए is_same<T, char>is_fundamental<T> के साथ भी प्रतिस्थापित कर सकते हैं (लेकिन उपयोगकर्ताओं को अभी भी मानक लाइब्रेरी प्रकारों के सरणी के लिए इसका उपयोग नहीं करना चाहिए)।

Answer 2

एक और तरीका है तुम कर सकते हो यह निम्नलिखित की तरह कुछ होगा:

template<typename T> 
ostream& operator<<(ostream &out, const std::pair<T, int>& array) 
{ 
    //...code 
    return out; 
} 

कहाँ T एक सरणी के लिए सूचक ले जाएगा (यानी, यह सूचक प्रकार है कि सरणी में क्षय होगा हो जाएगा) , और जोड़ी के int भाग सरणी का आकार होगा। इसके बाद आप निम्नलिखित की तरह उपयोग कर सकते हैं: इस विधि के साथ

int array[10]; 
//...some code that initializes array, etc. 

cout << make_pair(array, 10); 

एक प्लस यह भी गतिशील सरणियों के लिए काम करेंगे है (यानी, सरणियों आप ढेर पर आवंटित आदि)