如何为集合建立索引并允许每个索引变量具有自定义设置器？

Question

所以我有一个名为 Vertex 的对象，它包含一些参数（我们称它们为 sx、sy 和 i）。 sx、sy 和 i 每个都有特殊的设置器：即 Vertex 看起来像

class Vertex {
    public:
        float sx() { return sx; };

        void setSx(float val) {
            val > 0 ? sx = val : sx = 0;
        };

        float sy() { return sy; };

        void setSy(float val) {
            val >= 0 ? sx = val * 0.5 : sx = -val;
        };

        float i() { return i; };

        void setI(float val) { i = val; };

    private:
        float sx, sy, i;
};

我希望能够迭代 Vertex 的参数，而不必调用每个 setter。例如：

Vertex* v = new Vertex();
for (int i = 0; i < Vertex::size; i++)
    (*v)[i] = 0;

或者类似的东西，而不必使用更笨重的符号：

Vertex* v = new Vertex();
v->sx = 0;
v->sy = 0;
v->i = 0;

有没有什么方法可以以更优雅的方式实现这一点，而不仅仅是重载 operator[] 和使用 switch< /代码>声明？我不需要使用上面演示的确切符号，我只需要一种方法来迭代 Vertex 的组件，而不关心每个组件的自定义设置器。

Answer 1

窃取 James Curran 的内容（并稍作修改）：（

James 如果您想声明此方法，我将删除）。 :-)

class Vertex {
  public:
    float sx() const        {return data[0];}
    float sy() const        {return data[1];}
    float i()  const        {return data[2];}

    void setSx(float val)   {data[0] = val >  0 ? val       : 0;   }
    void setSy(float val)   {data[1] = val >= 0 ? val * 0.5 : -val;}
    void setI(float val)    {data[2] = val;                        }

    float& operator[](int n)
    {
           return data[n];
    }

    float const& operator[](int n) const
    {
           return data[n];
    }

    static std::size_t size() {return 3;}

  private:
    float data[3];
};

Answer 2

您可以创建一个指向浮点数的指针数组，并对其进行索引，但我不确定结果是否符合“最优雅”的条件

class Vertex { 
      float* varptr[3];
    public: 
        Vertex ()
        {
              varptr[0] = &(this.sx);
              varptr[1] = &(this.sy);
              varptr[2] = &(this.i);
         }
         float& operator[](int n)
         {
               return *varptr[n];
         }

Answer 3

重置方法怎么样()。
或者只是在构造函数中执行此操作，以便在创建对象时正确初始化对象。