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