Birden çok işleçlerin aşırı yüklenmesi

Question

Özet olarak, amacım foo [bar] return1 ve foo [bar] = return type2 olmaktır.

C++ 'da bir nesne yazıyorum ve oldukça güzel geliyor, ancak yapmak istediğim küçük bir şey var, ama imkansız görünüyor.

Nesnem bir depolama sınıfı, bu yüzden değerlere erişmek için bir dizi alt kümesi kullanıyorum. Ayrıca atamam gerekiyor, bu yüzden de = operatörünü aşırı yüklüyorum. Ancak, biraz rahatsız edici çünkü sınıfımın sahip olduğu değerler birinci sınıf nesnelerdir, bu yüzden dizi altbilgisi yüklerim için onları olduğu gibi iade edemiyorum. = İşleci kullanmak için bir orta sınıf döndürmem gerekiyor, ancak ek yazmadan da değeri almak istiyorum.

Bunu yapmanın bir yolu var mı? Hakikat yolları kabul edilebilir.

Düzenleme: İşte yine

#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 

Edit do (olmalı) ne bir örnek: Ben farklı bir bu phrasing çalışacağım düşünüyorum, ama çalışılabilir bir yol. Bir sınıf referans alındığında dönüş türünü aşırı yüklemenin bir yolu var mı? Aslında, bu gerçekten çalışacak şekilde

mu?

Answer 1

operator[]= yoktur, bu nedenle çözüm, iki temel özellik içeren bir tür sarıcı sınıfı yazmaktır: bir değer alan ve onu ana kapsayıcıya ayarlayan bir operator= ve bu değeri alan bir örtük dönüştürme işleci Ebeveyn kabı ve döndürür. operator[], daha sonra bu tür sarıcıları iade edecektir.

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); 
    } 
}; 

ikinci soru için, iyi, her zaman foo üzerinde operator== aşılmasına neden olabilir. Ama belki yanlış anladım. Eğer (Lütfen etiket anlaşılacağı gibi) C++ kullanmaya istekli iseniz

Answer 2

ardından işlerin çoğunu sizin için yapılmıştır:

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; 
}