C++超載[]操作不

Question

我創建了一個結構類：

struct a{ 
    int a1; 
    int a2; 
    int a3; 
}; 

有什麼辦法來創建一個函數，其中a[1]會以同樣的方式，我就可以給a1訪問通過數組？

編輯，我已經粘貼，我實際上做的部分：

struct lipid{ 
    particle mainPart; 
    bead * head; 
    bead * body; 
    bead * tail; 
    vec direction; 
    bead * operator[](int index){ 
    switch(index){ 
    case 0: return head; 
    case 1: return body; 
    case 2: return tail; 
    default: return body; 
    } 
    } 
}; 

珠和顆粒是我創造了另一種結構。它的工作原理...感謝

Answer 1

正如delnan指出，你可以使用方法上的結構，就像類一樣。

所以：

struct a{ 
    int a1; 
    int a2; 
    int a3; 
    int &operator[](int i){ 
     switch(i){ 
     case 1: return a1; 
     case 2: return a2; 
     case 3: return a3; 
     default: return -1 
     } 
    } 
}; 

Answer 2

最後一行11.8節（運算符重載，下標）在Stroustrup的 'C++程序設計語言' 的：

'An operator []() must be a member function.' 

所以，不，這是不可能的C++。

（儘管當然是struct是C++中的class，但我相信你的意思是你想struct a仍然是一個POD）

Answer 3

好吧，如果你一定要，你可以解決它與工會，雖然你可在得到皺眉道：

union 
{ 
    struct 
    { 
     int a1; 
     int a2; 
     int a3; 
    }; 
    int a[]; // may need compiler-specific tweaking 
}; 

請注意，並非所有編譯器支持int a[]，你可能得寫int a[0]甚至int a[3]，這取決於編譯器/語言的方言。

Answer 4

我們假設struct a位於某個庫中，並且您無法更改它，否則您會採用@ delnan的typedef建議（typedef int a[3]）。

如果結構不使用多態，你可能濫用繼承和自己添加操作：

struct a_with_brackets : public a 
{ 
    int& operator[](int index) 
    { 
     switch(index) 
     { 
     case 1 : return a1; 
     case 2 : return a2; 
     case 3 : return a3; 
     } 
    } 
}; 

Answer 5

struct a{ 
    int a1; 
    int a2; 
    int a3; 

    int & operator[](int i) { 
     if (i == 0) { 
     return a1; 
     } 
     else if (i == 1) { 
     return a2; 
     } 
     else if (i == 2) { 
     return a3; 
     } 
     else { 
     throw "index error"; 
     } 


}; 

Answer 6

由於operator [] must be a member function，如由他人注意，你不能這樣做。

但我想出了所謂subscriptable以下包裝類，它可以幫助你模擬它：

class subscriptable 
{ 
    A & a; 
    public: 
    subscriptable(A & a) : a(a) {} 
    subscriptable(const subscriptable & s) : a(s.a) {} 
    int & operator[](int i) 
    { 
     if (i < 0 || i > 2) throw "index out of range"; 
     else if (i == 0) return a.a1; 
     else if (i == 1) return a.a2; 
     else return a.a3; 
    } 
    operator A &() { return a; } 
}; 
void print(A & a) 
{ 
    subscriptable s = a; //a implicitly converts to subscriptable 
    for (int i = 0 ; i < 3 ; i++) 
     std::cout << s[i] << std::endl; 
} 
int main() 
{ 
     A a; 
     subscriptable s = a; //a implicitly converts to subscriptable 
     for (int i = 0 ; i < 3 ; i++) 
      s[i] = (i + 1) * 100; 
     print(s); //s implicitly converts to A 
     return 0; 
} 

輸出：

100 
200 
300 

在線演示：http://www.ideone.com/ymmg1