在這種情況下，此運算符[]超載如何工作？

Question

我偶然發現此類：

class Vec3f 
{ 
    ... 
    float x, y, z; 
    ... 
}; 

inline float operator[](const int index) const 
{ 
    return (&x)[index]; 
} 

inline float& operator[](const int index) 
{ 
    return (&x)[index]; 
} 

該類使用[]進入到X，Y，Z值的數組中，使得 v [0]是在X中的值，V [ 1]是y中的值，v [2]是z中的值，但是

• return語句如何工作？
• 讀取它是否正確：「從由x的地址開始的索引指定的地址中獲取值」？
• Do（& x）必須在括號內，否則會返回x [index]的地址值，不是嗎？

Answer 1

從技術上講，這不是有效的代碼。

但正在發生的事情：

// Declare four variables 
// That are presumably placed in memory one after the other. 
float x, y, z; 

在代碼：

return (&x)[index]; 

// Here we take the address of x (thus we have a pointer to float). 
// The operator [] when applied to fundamental types is equivalent to 
// *(pointer + index) 

// So the above code is 
return *(&x + index); 
// This takes the address of x. Moves index floating point numbers further 
// into the address space (which is illegal). 
// Then returns a `lvalue referring to the object at that location` 
// If this aligns with x/y/z (it is possible but not guaranteed by the standard) 
// we have an `lvalue` referring to one of these objects. 

它很容易使這項工作，是合法的：

class Vec3f 
{ 
    float data[3]; 
    float& x; 
    float& y; 
    float& z; 

    public: 
     float& operator[](const int index) {return data[index];} 

     Vec3f() 
      : x(data[0]) 
      , y(data[1]) 
      , z(data[2]) 
     {} 
     Vec3f(Vec3f const& copy) 
      : x(data[0]) 
      , y(data[1]) 
      , z(data[2]) 
     { 
      x = copy.x; 
      y = copy.y; 
      z = copy.z; 
     } 
     Vec3f& operator=(Vec3f const& rhs) 
     { 
      x = rhs.x; 
      y = rhs.y; 
      z = rhs.z; 
      return *this; 
     } 
};