अतिभारित ऑपरेटर फेंक नहीं अपवाद

Question

मैं एक वर्ग है कि एक नक्शा

Any& Map::operator[](const unsigned int field) const 
{ 
    try 
    { 
    iterator it; 
    if ((it = m_fields.find(field)) != m_fields.end()) 
     return it->second; 

    throw std::runtime_error("Field " + boost::lexical_cast<std::string>(field) + " not found."); 
    } 
    catch(boost::bad_any_cast&) 
    { 
    throw std::runtime_error("Failed conversion field " + boost::lexical_cast<std::string>(field) + " using boost::any_cast "); 
    } 
} 

मैं जब क्षेत्र मानचित्र में मौजूद है तो कार्यक्रम एक बुरी बात पर क्रैश नहीं होता नहीं है यह एक अपवाद फेंक करना चाहते हैं है, लेकिन फेंक ओवरलोडेड ऑपरेटर पर काम नहीं कर रहा है, प्रोग्राम किसी भी तरह दुर्घटनाग्रस्त हो जाता है ताकि फेंक या पकड़ को अनदेखा किया जा सके। यदि मैं एक ही कोड का उपयोग करता हूं लेकिन एक सामान्य फ़ंक्शन के साथ

Any& Map::get(const unsigned int field) const 
{ 
    //... 

यह काम करता है।

क्या मैं कुछ सी ++ सीमा में भाग गया था या क्या मैं कुछ गलत कर रहा हूं?

--EDIT:

मैं डिबगर भाग गया और मेरे आश्चर्य है कि कोड भी निष्पादित नहीं करता है करने के लिए, किसी अन्य विधि

Any& Map::operator[](const unsigned int field) 
{ 
    iterator it; 
    if ((it = m_fields.find(field)) == m_fields.end()) 
    { 
    Any newValue; 
    m_fields[field] = newValue; 
    return m_fields[field]; 
    } 

    return it->second; 
} 

करता है और दुर्घटना को बढ़ावा के कारण होती है पर जोर कोई भी जो एक अनियमित चर को परिवर्तित करने का प्रयास करता है। इस विधि शायद

Map a; 
a[3] = "foo"; 

की तरह, नक्शे पर आवेषण पर प्रयोग किया जाता है तो मुझे लगता है मैं जब ऑपरेटर एक atribution पर या किसी और इस ऑपरेटर के उपयोग पर प्रयोग किया जाता है अंतर करने के लिए कोई रास्ता नहीं है लगता है के लिए अत्यधिक असुरक्षित है

Answer 1

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

ऐसे मामले में जहां आप उपयोग के आधार पर अलग-अलग व्यवहार चाहते हैं, पारंपरिक समाधान प्रॉक्सी प्रदान करना है।

class Proxy // member of Map 
{ 
    Map* myOwner; 
    int myIndex; 
public: 
    Proxy(Map* owner, int index) 
     : myOwner(owner) 
     , myIndex(index) 
    { 
    } 
    void operator=(Any const& rhs) const 
    { 
     myOwner->put(myIndex, rhs); 
    } 
    operator Any() const 
    { 
     return myOwner->get(myIndex); 
    } 
};