एकाधिक ऑपरेटरों को ओवरलोड करना

Question

संक्षेप में, मेरा लक्ष्य foo [bar] वापसी प्रकार 1, और foo [bar] = return type2 होना है।

मैं सी ++ में एक ऑब्जेक्ट लिख रहा हूं, और यह काफी अच्छी तरह से आ रहा है, हालांकि एक छोटी सी छोटी चीज है जो मैं करना चाहता हूं, फिर भी यह असंभव प्रतीत होता है।

मेरा ऑब्जेक्ट एक स्टोरेज क्लास है, इसलिए मैं मानों तक पहुंचने के लिए सरणी सबस्क्रिप्ट का उपयोग कर रहा हूं। मुझे असाइन करने की भी आवश्यकता है, इसलिए मैं = ऑपरेटर को भी अधिभारित करता हूं। हालांकि, यह कुछ हद तक असुविधाजनक है क्योंकि मेरी कक्षा के मान जो प्रथम श्रेणी की वस्तुएं हैं, इसलिए मेरे सरणी सबस्क्रिप्ट अधिभार के लिए मैं उन्हें वापस नहीं कर सकता। मुझे = ऑपरेटर को संभालने के लिए एक इंटरमीडिएट क्लास वापस करना होगा, लेकिन मैं अतिरिक्त टाइपिंग के बिना भी मूल्य पुनर्प्राप्त करना चाहता हूं।

क्या ऐसा करने का कोई तरीका है? हैकिश तरीके स्वीकार्य हैं।

संपादित करें: यहाँ क्या इसे फिर से (चाहिए)

#include<cstdio> 
#include<cstdlib> 

class foo{ 
    char* a[100]; 
    foo(){ 
     for(int i = 0; i < 100; i ++) 
      a[i] = 0; 
    } 
    char* operator[] (int location){ 
     return a[location]; 
    } 
    foo& operator[]= (int location, const char* value){ 
     if(a[location] == 0) 
      a[location] = (char*) malloc(strlen(value) + 1); 
     else 
      a[location] = (char*) realloc(a[location], strlen(value) + 1); 
     strcpy(a[location], value); 
    } 
}; 
int main(){ 
    foo bar; 
    bar[20] = "Hello"; 
    printf("bar[20] = %s\n", bar[20]); 
    bar[20] = "Hello There"; 
    printf("bar[20] = %s\n", bar[20]); 
    printf("bar[20][0] = %c\n", bar[20][0]); 
} 

Output: 
bar[20] = Hello 
bar[20] = Hello There 
bar[20][0] = H 

संपादित का एक उदाहरण है: मुझे लगता है मैं एक अलग में इस phrasing कोशिश करता हूँ, लेकिन व्यावहारिक तरीका है। कक्षा के संदर्भ में रिटर्न प्रकार को अधिभारित करने का कोई तरीका है? ऐसा है कि अगर मेरे पास

class foo{ 
    bool a; 
    bool operator /*referenced*/(){ 
     return a 
    } 
    foo& operator=(bool b){ 
     a = b; 
    } 
}; 
int main(){ 
    foo a; 
    a = b; 
    if(a == b) 
     printf("It Works!"); 
} 

वास्तव में काम करेगा?

Answer 1

कोई operator[]= नहीं है, इसलिए समाधान दो प्रमुख विशेषताएं साथ आवरण वर्ग के कुछ प्रकार लिखने के लिए है: एक operator= कि एक मूल्य लेता है और माता पिता के कंटेनर के लिए यह निर्धारित करता है, और एक अंतर्निहित रूपांतरण ऑपरेटर से मूल्य लेता है माता-पिता कंटेनर और इसे वापस कर देता है। आपका operator[] फिर ऐसे रैपर को वापस कर देगा।

class foo 
{ 
    friend class wrapper; 
public: 
    class wrapper 
    { 
     friend class foo; 
     foo & _parent; 
     int _index; 

     wrapper(foo & parent, int index) : _index(index), _parent(parent) {} 
    public: 
     wrapper & operator=(const char * value) 
     { 
      if(_parent.a[_index] == 0) 
       _parent.a[_index] = (char*) malloc(strlen(value) + 1); 
      else 
       _parent.a[_index] = (char*) realloc(_parent.a[_index], strlen(value) + 1); 
      strcpy(_parent.a[_index], value); 

      return *this; 
     } 

     operator char *() 
     { 
      return _parent.a[_index]; 
     } 
    }; 

    char* a[100]; 
    foo() 
    { 
     for(int i = 0; i < 100; i ++) 
      a[i] = 0; 
    } 
    wrapper operator[] (int location){ 
     return wrapper(*this, location); 
    } 
}; 

दूसरे प्रश्न के लिए, अच्छी तरह से, आप हमेशा operator==foo पर ओवरलोड सकता है। लेकिन शायद मैं गलत समझा।

Answer 2

यदि आप (आपके टैग से पता चलता है) C++ उपयोग करने के लिए तैयार हैं, तो काम के सबसे आप के लिए किया गया है:

class foo: public vector<string> 
{ 
public: 
    foo() 
    { 
    resize(100); 
    } 
}; 

int main() 
{ 
    foo bar; 

    bar[20] = "Hello"; 
    cout << "bar[20] = " << bar[20] << endl; 
    bar[20] = "Hello There"; 
    cout << "bar[20] = " << bar[20] << endl; 
    cout << "bar[20][0] = " << bar[20][0] << endl; 
}