Question

我在C ++中有一个依赖于原始指针的向量类。我不使用std :: vector，因为我需要从原始指针创建矢量对象以用于特定情况。这是我班级的一个非常简单的例子：

template <typename T>
class Vector
{ ...
  private:
    T * m_data; int m_size; bool dontFree; ...
  public:
    Vector(T *const ptr, int size) { m_data = ptr; m_size = size; dontFree = true; }
    Vector(int size, T val) {  ...  dontFree = false; }
    ~Vector(): {   if(!dontFree) delete [] m_data; }
    T& operator[](const size_type index);
};

类似地，我有矩阵数据类型，它也将数据存储在原始指针中，并且可以使用vector来支持[] []，因为它在C ++中是不允许的，例如：

template<typename T>
class Matrix
{
  private:
   T * m_data; ...

 public:
  ... 
  Vector<T>& operator[](const int rowIndex)
  {
     return Vector<T>(&m_data[rowSize * rowIndex], rowSize);
  }
}

我怎样才能有效地实现operator [] for matrix returing a Vector，以便我可以编写代码，如下所示：

Matrix<int> m(5,5);
m[1][1] = 10;
int temp = m[1][2];

请建议考虑复制构造函数等的开销。

Answer 1

创建一个重载operator []的代理类，您可以访问矩阵的数组。像这样：

template<typename T>
class Proxy
{
public:
    Proxy(T * tp)
        :rowStart(tp)
    {}

    T & operator[](const int columnIndex)
    {
        return rowStart[columnIndex];
    }

private:
    T * rowStart;
};

然后你的Matrix类'operator []可以返回其中一个，如下所示：

Proxy<T> operator[](const int rowIndex)
{
     return Proxy<T>(m_data + rowSize * rowIndex);
}

当然不完整，但它应该让你开始。

Answer 2

您应该按值返回向量以使代码正确。如果你的向量在复制构造函数中做了很多工作，你也可以编写一个小代理。

如果您将operator[]实现为内联方法（例如，不要将实现移动到cpp），那么优秀的编译器应该优化您的代码并消除不必要的复制。

但是如果你对性能感到疯狂，那么你可以从运算符返回一个原始指针：

... 
T* operator[](const int rowIndex)
{
  return m_data + rowSize * rowIndex;
}
...
int temp = m[1][2];

但这是一种危险的方法！

Answer 3

实现多维矩阵时的建议不是重载operator[]，而是重载operator()多维。您可以在C++ FAQ lite

中阅读以下几个原因

template <typename T>
class Matrix {
public:
   typedef std::size_t size_type;
   typedef T & reference;
   typedef T const & const_reference;

   const_reference operator()( size_type x, size_type y ) const;
   reference operator()( size_type x, size_type y );
};

C ++和operator []中的自定义Vector和Matrix类

3 个答案: