如何定义双括号/双迭代器运算符，类似于向量的向量？

Question

我正在移植使用大量浮点数的代码，这可能会触发从 c 到 c++ 的 malloc 失败。我问了一个关于我应该使用向量还是双端队列的问题，Niki Yoshiuchi 慷慨地为我提供了这个安全包装类型的示例：

template<typename T>
class VectorDeque
{
private:
  enum TYPE { NONE, DEQUE, VECTOR };
  std::deque<T> m_d;
  std::vector<T> m_v;
  TYPE m_type;
  ...
public:
  void resize(size_t n)
  {
    switch(m_type)
    {
      case NONE:
      try
      {
        m_v.resize(n);
        m_type = VECTOR;
      }
      catch(std::bad_alloc &ba)
      {
        m_d.resize(n);
        m_type = DEQUE;
      }
      break;
    }
  }
};

我需要一个二维向量/双端队列，所以我将其修改为以下代码：

template<typename T>
class VectorDeque
{
private:
  enum STORAGE_CONTAINER { NONE, DEQUE, VECTOR };
  std::deque<std::deque<T> > x_d,y_d,z_d;
  std::vector<std::vector<T> > x_v,y_v,z_v;
  TYPE my_container;
public:
  void resize(size_t num_atoms, size_t num_frames)
  {
    switch(m_type)
    {
      case NONE:
      try
      {
        x_v.resize(num_atoms);
 for (unsigned int couter=0;couter < num_frames; counter++)
   x_v[counter].resize(num_frames);
        y_v.resize(num_atoms);
 for (unsigned int couter=0;couter < num_frames; counter++)
   y_v[counter].resize(num_frames);
        z_v.resize(num_atoms);
 for (unsigned int couter=0;couter < num_frames; counter++)
   z_v[counter].resize(num_frames);
        my_container = VECTOR;
      }
      catch(std::bad_alloc &e)
      {
        x_d.resize(num_atoms);
 for (unsigned int couter=0;couter < num_frames; counter++)
   x_d[counter].resize(num_frames);
        y_d.resize(num_atoms);
 for (unsigned int couter=0;couter < num_frames; counter++)
   y_d[counter].resize(num_frames);
        z_d.resize(num_atoms);
 for (unsigned int couter=0;couter < num_frames; counter++)
   z_d[counter].resize(num_frames);
        my_container = DEQUE;
      }
      break;
    }
  }
};

我现在希望能够定义我的括号运算符，以便我可以有一个类似的语句 x[1][2] 直接访问我正在使用的 real 内存容器（由我的枚举变量的值给出。

我已经看过一些关于重写括号运算符的教程，但肯定不知道要重写双括号。

如何使双括号重载？

此外，您将如何重载双迭代器（如果我想使用迭代器，而不是直接索引）？

编辑1：

基于 Martin York/Matteo Italia 的解决方案，我设计了以下课程：

template<typename T>
class VectorDeque2D
{
public:

  class VectorDeque2D_Inner_Set
  {
    VectorDeque2D& parent;
    int   first_index;
  public:
    // Just init the temp object
    VectorDeque2D_Inner_Set(My2D& p, int first_Index) : 
      parent(p), 
      first_Index(first_index) {} 
    // Here we get the value.
    T& operator[](int second_index)  const 
    { return parent.get(first_index,second_index);}   
  };

  // Return an object that defines its own operator[] that will access the data.
  // The temp object is very trivial and just allows access to the data via 
  // operator[]
  VectorDeque2D_Inner_Set operator[](unsigned int first_index) { 
    return (*this, x);
  }


  void resize_first_index(unsigned int first_index) {
    try {
      my_vector.resize(first_index);
      my_container = VECTOR;
    }
    catch(std::bad_alloc &e) {
      my_deque.resize(first_index);
      my_container = DEQUE;
    }
  }

  void resize_second_index(unsigned int second_index) {
    try {
      for (unsigned int couter=0;couter < my_vector.size(); counter++) {
    my_vector[counter].resize(second_index);
      }
      my_container = VECTOR;
    }
    catch(std::bad_alloc &e) {
      for (unsigned int couter=0;couter < my_deque.size(); counter++) {
    my_deque[counter].resize(second_index);
      }
      my_container = DEQUE;
    }
  }
  void resize(unsigned int first_index,
          unsigned int second_index) {
    try {
      my_vector.resize(first_index);
      for (unsigned int couter=0;couter < my_vector.size(); counter++) {
    my_vector[counter].resize(second_index);
      }
      my_container = VECTOR;
    }
    catch(std::bad_alloc &e) {
      my_deque.resize(first_index);
      for (unsigned int couter=0;couter < my_deque.size(); counter++) {
    my_deque[counter].resize(second_index);
      }
      my_container = DEQUE;
    }    
  }
private:
  enum STORAGE_CONTAINER { NONE, DEQUE, VECTOR };

  friend class VectorDeque2D_Inner_Set;

  std::vector<std::vector<T> > my_vector;
  std::deque<std::deque<T> > my_deque;
  STORAGE_CONTAINER my_container;

  T& get(int x,int y) { 
    T temp_val;
    if(my_container == VECTOR) {
      temp_val = my_vector[first_index][second_index];
    }
    else if(my_container == DEQUE) {
      temp_val = my_deque[first_index][second_index];
    }

    return temp_val;
  }

};

终于有一个尺寸安全的 2D 容器了！！谢谢大家！

Answer 1

主要有两种技术：

1) 使用 operator() 而不是 operator[]。
这是因为 operator() 允许多个参数。

class My2D
{
    public:
       int&   operator()(int x,int y)  { return pget(x,y);}
    private:
       int&   pget(int x,int y) { /* retrieve data from 2D storage */ }
};

2) 使用 operator[] 但返回一个中间对象。
然后，您可以将第二个 operator[] 应用于中间对象。

class My2D
{
    public:
       class My2DRow
       {
           My2D& parent;
           int   x;
           public:
               My2DRow(My2D& p, int theX) : parent(p), x(theX) {}     // Just init the temp object
               int& operator[](int y)  const { return parent.pget(x,y);}   // Here we get the value.
       };

       // Return an object that defines its own operator[] that will access the data.
       // The temp object is very trivial and just allows access to the data via operator[]
       My2DRow operator[](int x)        { return My2DRow(*this, x);}
    private:
       friend class My2DRow;
       int&   pget(int x,int y) { /* retrieve data from 2D storage */ }
};

int main()
{
    My2D   data;
    int&   val = data[1][2]; // works fine.

    // This is the same as
    My2D::My2DRow row  = data[1];
    int&          val2 = row[2]; 
}

我更喜欢第二种技术。
这是因为它使原始代码保持不变并且更自然地阅读（在数组上下文中）。当然，您需要为实现 2D 数组的稍微复杂的代码在高层次上的简单性付出代价。

Answer 2

如何使双括号重载？

我没有完全理解你的问题，但是你必须重载括号，并让它们返回一个重载自己的括号运算符的对象。

例如，如果您有一个向量向量，则工作已经完成：vector < vector < something > > 重载operator[]，它返回一个vector< something >；反过来，它的括号运算符重载（并且它返回一个something 对象），所以你可以简单地这样做：

vector<vector<something> > vec;
// ...
something s = vec[2][3];

---

带有代理对象的示例：

template <typename T>
class Container
{
private:
    // ...


public:

    // Proxy object used to provide the second brackets
    template <typename T>
    class OperatorBracketHelper
    {
        Container<T> & parent;
        size_t firstIndex;
    public:
        OperatorBracketHelper(Container<T> & Parent, size_t FirstIndex) : parent(Parent), firstIndex(FirstIndex) {}

        // This is the method called for the "second brackets"
        T & operator[](size_t SecondIndex)
        {
            // Call the parent GetElement method which will actually retrieve the element
            return parent.GetElement(firstIndex, SecondIndex);
        }

    }

    // This is the method called for the "first brackets"
    OperatorBracketHelper<T> operator[](size_t FirstIndex)
    {
        // Return a proxy object that "knows" to which container it has to ask the element
        // and which is the first index (specified in this call)
        return OperatorBracketHelper<T>(*this, FirstIndex);
    }

    T & GetElement(size_t FirstIndex, size_t SecondIndex)
    {
        // Here the actual element retrieval is done
        // ...
    }
}

（在适当的地方添加重载的 const 方法:)）

请注意，使用这种方法，与operator() 实现相比，您几乎不会损失任何东西，因为检索仍然在一个地方完成，对两个索引的使用没有限制，在执行时同时拥有两个索引检索，并且不返回“胖”临时对象（OperatorBracketHelper 与两个指针一样大，并且可以很容易地被编译器优化掉）。

Answer 3

C++ 中没有“双括号”运算符。您需要做的是定义一个[] 运算符并让它返回对另一个对象的引用，该对象又可以响应它自己的[] 运算符。可以根据需要嵌套任意多个级别。

例如，当您创建一个向量向量时，外部向量上的[] 运算符返回对内部向量之一的引用；该向量上的 [] 运算符返回对向量单个元素的引用。

std::vector<std::vector<float> > example;
std::vector<float> & first = example[0];  // the first level returns a reference to a vector
float & second = example[0][0];  // the same as first[0]

Answer 4

不要重载[] 运算符，重载() 运算符。

查看此链接：Overloading Subscript Operator.

我强烈建议在发布到 Stack Overflow 之前至少阅读 C++ FAQ Lite 一次。此外，搜索 Stack Overflow 也可能会产生一些有用的信息。

Answer 5

我在answer to a previous question 中介绍了多维数组的重载运算符[]。

我可能会非常相似地处理迭代器：有一个迭代器代表多维数组的“切片”（行或列），然后另一个迭代器代表该切片中的一个元素。