दो काम करता है, को वापस लौटाते इटरेटर, अन्य लौटने const_iterator

Question

तो मैं एक समारोह खोज कहा जाता है, जो दो संस्करण उपयोग कैसे करें:

template <typename T> 
typename btree<T>::iterator btree<T>::find(const T& elem) 
{ 
    //Implementation 
} 

और अन्य const_iterator संस्करण है:

template <typename T> 
typename btree<T>::const_iterator btree<T>::find(const T& elem) const 
{ 
    //Implementation 
} 

अपने परीक्षण फ़ाइल जब मैं

btree<char>::iterator it = myTree.find('M'); 

सब कुछ ठीक काम करता है करते हैं, लेकिन जब मैं const_iterat का उपयोग में या संस्करण:

btree<char>::const_iterator it = myTree.find('M'); 

यह मुझे त्रुटि

error: conversion from 'btree_iterator' to non-scalar type 'const_btree_iterator' requested

कौन सा स्पष्ट रूप से इसका मतलब है कि खोजने ही कभी इटरेटर (गैर const) संस्करण का उपयोग कर रहा है देता है। मुझे पता है कि सी ++ को const_iterator संस्करण स्वचालित रूप से कॉल करना है - अगर मैंने सब ठीक किया था। तो सवाल यह है कि, मैं गलत क्या कर सकता हूं?

इटरेटर वर्ग हैं:

class btree_iterator और class const_btree_iterator जो नाम के साथ btree_iterator का सिर्फ एक कॉपी पेस्ट है बदल

यहाँ पूर्ण स्रोत कोड हैं:
btree_iterator.h (शामिल const_btree_iterator) http://pastebin.com/zQnj9DxA
btree.h http://pastebin.com/9U5AXmtV
btree.tem http://pastebin.com/U9uV3uXj

Answer 1

सभी मानक कंटेनर स्थिरांक iterators करने के लिए गैर स्थिरांक के रूपांतरण (specified in the requirements for the Container concept के रूप में) को लागू:

class btree_iterator; 
class const_btree_iterator 
{ 
     // .... 
     public: 
       const_btree_iterator(const btree_iterator& rhs) { /* .... */ } 
//optionally: const_btree_iterator& operator=(const btree_iterator& rhs) { /* .... */ } 
}; 

मैं भी असाइनमेंट ऑपरेटर में फेंक दिया, लेकिन मुझे लगता है:

The type of iterator used to iterate through a container's elements. The iterator's value type is expected to be the container's value type. A conversion from the iterator type to the const iterator type must exist.

तुम इतनी तरह रूपांतरण निर्माता की जरूरत यह अनावश्यक है

Answer 2

यहां महत्वपूर्ण बात यह है कि ओवरलोड रिज़ॉल्यूशन केवल फ़ंक्शन के तर्कों पर आधारित होता है न कि नतीजे पर। आपके विशेष मामले में आपके पास दो अलग-अलग अधिभार हैं और अंतर यह है कि अंतर्निहित this उनमें से एक में निरंतर है, जब ऑब्जेक्ट का स्थिर प्रकार या संदर्भ जिस पर विधि कहा जाता है, तब अधिभार लोड किया जाएगा।

आप निरंतर अधिभार के लिए प्रेषण के लिए मजबूर करना चाहते हैं, तो आप एक स्थिरांक संदर्भ प्राप्त कर सकते हैं और फिर उस संदर्भ पर कॉल:

btree<char> const & r = myTree; 
btree<char>::const_iterator it = r.find('M'); 

आप वास्तविक कोड में इस संरचना से बचना चाहिए, भले ही आप के लिए इसका इस्तेमाल करते हैं परीक्षण उद्देश्यों। इसका कारण यह है कि कॉन्स और गैर-कॉन्स ओवरलोड में समान अर्थशास्त्र होना चाहिए और इस प्रकार व्यवहार समान होना चाहिए।

यह भी ध्यान दें कि मानक कंटेनरों में, iterator से const iterator से const_iterator एस का उपयोग करने के लिए सीधे गैर-कॉन्स कंटेनर पर एक निहित रूपांतरण है।आप भी ऐसा ही करना चाहिए, वह यह है कि, अगर आप iterator से const_iterator को एक अंतर्निहित रूपांतरण प्रदान करते हैं, तो आप सिर्फ लिख सकते हैं:

btree<char>::const_iterator it = myTree.find('M'); 

... और यह काम करेंगे (find विधि का परीक्षण नहीं होगा, लेकिन होगा आपको const_iterator व्यवहार को सत्यापित करने की अनुमति देता है)