稀疏矩阵，overloading= c++

Question

我需要在我的类= operator中超载SparseMatrix。

template <class T>
class SparseMatrix
{

  public:
  template <class T>
  class element
  {
  public:
      int x;
      int y;
      T val; 
      element(T war, int x1, int y1) { val = war; x = x1; y = y1; };
   };

  vector<element<T>> diff; //contains a cell with diffrent value
  T value; //contains a value of all cells at begining.
  int sizeX;
  int sizeY;

  SparseMatrix(T val, int x, int y) { value = val; sizeX = x; sizeY = y; };
  ~SparseMatrix() {};

  T& operator()(int t, int t1)
  {
    for (int x = 0; x < diff.size(); x++)
    if (diff[x].x == t && diff[x].y == t1)
        return diff[x].val;
    return value;
  }
};

如果我键入mat(1,1) = 5，程序将生成一个参数为x=1、y=1、val=1的新元素，并在向量差分中将该元素向前推回。

Answer 1

考虑到您希望在像mat(1,1) = 5而不是mat = something这样的表达式中使用这个重载的operator=，所以您实际上不希望为矩阵本身重载operator=。相反，让operator()返回一个代理，您将为该代理重载操作符：

template <class T>
class SparseMatrix
{

  //...

  struct Proxy
  {
    int t, t1;
    SparseMatrix &mat;

    Proxy(int t, int t1, SparseMatrix &mat) : t(t), t1(t1), mat(mat) {}

    operator T() const {
      for (int x = 0; x < mat.diff.size(); x++)
        if (mat.diff[x].x == t && mat.diff[x].y == t1)
          return mat.diff[x].val;
      return mat.value;
    }

    T& operator= (const T &v) {
      for (int x = 0; x < mat.diff.size(); x++)
        if (mat.diff[x].x == t && mat.diff[x].y == t1)
          return mat.diff[x].val = v;  //it exists, assign & return it
      // it doesn't exist, create new one
      mat.diff.push_back(element<T>(v, t, t1));
      return mat.diff.back().val;
    }
  };

  Proxy operator() (int t, int t1) {
    return Proxy(t, t1, *this);
  }
};

您可以玩康斯特正确性，完美的转发，使Proxy不可复制等，但基本思想概述以上。

Answer 2

实际上，您只需要更新()的重载函数。

T& operator()(int t, int t1)
{
    for (size_t x = 0; x < diff.size(); x++)
    {
        if (diff[x].x == t && diff[x].y == t1)
            return diff[x].val;
    }

    diff.push_back(element(value,t,t1));
    return diff.back().val;
}