Question

我写了一个小型演示，它应该为三维[][][] operator实现一个伪std::vector。目的是调用[] operator直到返回类型T.不幸的是，程序似乎崩溃了，并且递归地调用了运算符。

#include <vector>
#include <iostream>

template <class T>
class V1D : public std::vector<T>
{
private:
  int _iX = 0;
  int _iBeg = 0;

public:
  V1D(int x, int beg, std::vector<T> &buf)
    : _iX(x)
  {
    this->swap(buf);
    _iBeg = beg;
  }

  T& operator[] (int id) {
    return (*this)[id + _iBeg];
  }
};

template <class T>
class V2D : public std::vector<T>
{
private:
  int _iX = 0;
  int _iY = 0;
  int _iBeg = 0;

public:
  V2D(int x, int y)
    : _iX(x)
    , _iY(y)
  {
    this->resize(_iX*_iY);
  }

  V2D(int x, int y, int beg, std::vector<T> &buf)
    : _iX(x)
    , _iY(y)
  {
    this->swap(buf);
    _iBeg = beg;
  }

  V1D<T> operator[] (int id) {
    int iBeg = id*_iX;
    return V1D<T>(_iX, iBeg+_iBeg, *this);
  }
};

template <class T>
class V3D : public std::vector<T>
{
private:
  int _iX = 0;
  int _iY = 0;
  int _iZ = 0;

public:
  V3D() = default;
  V3D(int x, int y, int z) 
    : _iX(x)
    , _iY(y)
    , _iZ(z) 
  {
    this->resize(_iX*_iY*_iZ);
  }

  V2D<T> operator[] (int id) {
    int iBeg = id*_iY*_iZ;
    return V2D<T>(_iY, _iZ, iBeg, *this);
  }
};

int main()
{
    V3D<float> v3(3, 3, 3);
    float v = v3[1][1][0];
    v3[1][1][0] = 5;
    v = v3[1][1][0];
    std::cout << v << std::endl;
}

Answer 1

我不认为在V1D和V2D构造函数（可能应该是私有的）中执行this-＆gt; swap（buf）是一个好主意。如果你考虑一下，V3D :: operator []将用你的变量中的任何东西来交换一个临时的空向量（它作为结果返回）。所以你放松了内容。这种设计不起作用。您可能需要将指针返回到包含在辅助类中的vector的数据中。

V1D和V2D不应该也不需要保持/是向量。它们应该包含普通的T指针，可能有内部大小。

Answer 2

您递归地致电operator[]

T& operator[] (int id) {
    return (*this)[id + _iBeg];
}

应该是

T& operator[] (int id) {
    return std::vector<T>::operator[](id + _iBeg);
}

我的重载[]运算符不适用于伪3D数组

2 个答案: