ऑपरेटर का उपयोग करते समय पढ़ने/लिखने के संचालन को अलग करने के लिए कैसे करें []

Question

मुझे एक ओवरलोडेड ऑपरेटर [] के साथ एक कक्षा लिखनी होगी, जिसमें ऑपरेटर [] का उपयोग डेटा पढ़ने या लिखने के लिए किया जाता है। मैं क्या हासिल करना चाहते का एक व्यावहारिक उदाहरण के लिए, मान लीजिए कि मैं एक वर्ग नामित फ़ोनबुक जो निम्नलिखित तरीके से इस्तेमाल किया जा सकता के कार्यान्वयन लिखने की करते हैं:

PhoneBook phoneBook(999999); // 999999 is the default number which should be 
          // used when calling someone who is not in the phone book 

phoneBook["Paul"] = 234657; // adds Paul's number 
phoneBook["John"] = 340156; // adds John's number 

// next line should print Paul's number 234657 
cout << "To call Paul dial " << phoneBook["Paul"] << endl; 
// next line should print John's number 340156 
cout << "To call John dial " << phoneBook["John"] << endl; 
// next line should print 999999 because Frank is not in the phone book 
cout << "To call Frank dial " << phoneBook["Frank"] << endl; 

समस्या वास्तव में यह है कि जब

phoneBook["Frank"] 

अन्यथा एक समाधान एसटीडी के आधार पर :: मानचित्र का उपयोग मैं फ्रैंक के लिए फोन बुक में एक प्रविष्टि जोड़ने के लिए नहीं करना चाहते, लागू करने के लिए आसान होगा।

मुझे कुछ सुझावों के बाद यह प्राप्त करने के लिए किसी भी मानक तरीके से वेब पर नहीं मिला, मैं निम्नलिखित समाधान के साथ आया जिसमें ऑपरेटर [] फोन नंबर नामक एक "अस्थायी वस्तु" देता है। PhoneNumber तो पढ़ें/लिखें संचालन के बीच भेद करने के लिए इस्तेमाल किया जाता है:

#include <iostream> 
#include <string> 
#include <map> 

using namespace std; 

class PhoneBook{ 
private: 
    map<string, int> data_; // stores phone numbers 
    int defaultNumber_; // default number returned when no matching name is found 

public: 
    PhoneBook(int defaultNumber) : 
     defaultNumber_(defaultNumber) {} 

    // Searches in the phone book for a name. If the name is found it returns 
    // the corresponding number. If the name is not found it returns defaultNumber_ 
    int read(string name){ 
     map<string, int>::iterator it = data_.find(name); 
     if (it==data_.end()){ 
      return defaultNumber_; 
     } else { 
      return it->second; 
     } 
    } 

    // Forwarding function to map operator []. It is not really necessary but it is added for clarity 
    int& write(string name){ 
     return data_[name]; 
    } 

    // Forward declaration of the "temporary object" returned by operator [] 
    // See declaration below 
    class PhoneNumber; 

    PhoneNumber operator[](string name){ 
     return PhoneNumber(this, name); 
    } 

    class PhoneNumber{ 
     friend class PhoneBook; 
    private: 
     PhoneBook* const phoneBook_; 
     string name_; 

     // Constructors are private so that PhoneNumber can be used only by PhoneBook 
     // Default constructor should not be used 
     PhoneNumber() : 
      phoneBook_(NULL) {} 

     PhoneNumber(PhoneBook* phoneBook, string name) : 
      phoneBook_(phoneBook), name_(name) {} 

    public: 
     // conversion to int for read operations 
     operator int(){ 
      return phoneBook_->read(name_); 
      } 

     // assignment operator for write operations 
     const int& operator = (const int& val){ 
      return phoneBook_->write(name_) = val; 
     } 
    }; 
}; 

int main(){ 
    PhoneBook phoneBook(999999); 

    phoneBook["Paul"] = 234657; 
    phoneBook["John"] = 340156; 

    cout << "To call Paul dial " << phoneBook["Paul"] << endl; 
    cout << "To call John dial " << phoneBook["John"] << endl; 
    cout << "To call Frank dial " << phoneBook["Frank"] << endl; 

    return 0; 
} 

वर्ग फ़ोनबुक बर्ताव करता है जैसे मुझे पसंद है और कार्यक्रम प्रिंट होगा:

To call Paul dial 234657 
To call John dial 340156 
To call Frank dial 999999 

मैं आपसे कुछ सवाल पूछना चाहूँगा:

1. क्या कक्षा को कोडित कोड की तरह व्यवहार करने का कोई बेहतर तरीका है?
2. क्या तकनीक मैं एक नाम का उपयोग कर रहा हूं ताकि मैं इसके बारे में अधिक जानकारी प्राप्त कर सकूं?
3. क्या आपको मेरे समाधान में कोई कमी/संभावित सुधार दिखाई देता है?

पुस्तकालय मैं लिख रहा हूँ में, व्यवहार मैं एक ऐसी ही स्थिति में फ़ोनबुक :: ऑपरेटर [] के लिए प्राप्त की सक्रिय करने के लिए वास्तव में महत्वपूर्ण है और मैं सच में जानना आप मेरी समस्या के बारे में क्या सोचते हैं।

धन्यवाद!

Answer 1

जो आप प्रस्तावित करते हैं वह इस समस्या का मानक समाधान है। यह आमतौर पर प्रॉक्सी पैटर्न या प्रॉक्सी मुहावरे के रूप में जाना जाता है, और हेल्पर क्लास जिसे आप रिटर्न प्रॉक्सी कहते हैं। (चूंकि यह एक नेस्टेड वर्ग है, बस बुला यह Proxy आम तौर पर पर्याप्त है।)

Answer 2

मुझे लगता है कि आप ऑपरेटर [], स्थिरांक संशोधक के साथ एक और बिना अन्य के दो संस्करणों को लागू कर सकते हैं। फिर यदि आपके पास ऑब्जेक्ट है PhoneBook phoneBook(999999);, यदि फोनबुक कॉन्स ऑब्जेक्ट है, तो केवल operator [] const कहा जा सकता है। यदि फोनबुक गैर-कॉन्स ऑब्जेक्ट है, तो डिफ़ॉल्ट operator [] कहा जाता है। यदि आप operator [] const को गैर-कॉन्स्ट ऑब्जेक्ट को कॉल करना चाहते हैं, तो आप static_cast<const PhoneBook&>(phoneBook)->operator[...] जैसे कलाकार जोड़ सकते हैं।

#include <iostream> 
#include <string> 
#include <map> 

using namespace std; 

class PhoneBook{ 
private: 
    map<string, int> data_; // stores phone numbers 
    int defaultNumber_; // default number returned when no matching name is found 

public: 
    PhoneBook(int defaultNumber) : 
     defaultNumber_(defaultNumber) {} 
    int operator [] (const string& name) const 
    { 
     map<string, int>::const_iterator it = data_.find(name); 
     if (it == data_.end()) 
     { 
      return defaultNumber_; 
     } 
     else 
     { 
      return it->second; 
     } 
    } 
    int& operator [] (const string& name) 
    { 
     return data_[name]; 
    } 
}; 

int main(){ 
    PhoneBook phoneBook(999999); 

    phoneBook["Paul"] = 234657; 
    phoneBook["John"] = 340156; 

    cout << "To call Paul dial " << phoneBook["Paul"] << endl; 
    cout << "To call John dial " << phoneBook["John"] << endl; 
    cout << "To call Frank dial " << static_cast<const PhoneBook&>(phoneBook)["Frank"] << endl; 

    return 0; 
}