C++ 模板复制构造函数，编译器说“传递 const 作为此参数丢弃限定符”

我正在尝试创建动态矩阵的模板类。以我目前对 C++ 的了解，我设法解决了一些问题，但我陷入了复制构造函数和重载运算符 =; 的困境。换句话说，我无法创建我的对象的副本。 在我看来，这应该可行，但我的朋友编译器告诉我，我有 1 个错误： 错误：将“const Matrix”作为“int Matrix::getElement(int, int) [with T = int]”的“this”参数传递会在这一行丢弃限定符[-fpermissive]：

m[i][j] = original.getElement(i, j);

当我想创建一个对象时：

Matrix<int> m = Matrix<int>(3, 3);

我的模板类在这里：

template<class T>class Matrix
{
 public:

  Matrix<T>(int lines, int columns)
  {
    this->lines = lines;
    this->columns = columns;
    T* aux = new T[this->lines * this->columns];
    m = new T*[lines];
    for (int i = 0; i < this->lines; i++)
    {
      m[i] = aux + (i * this->columns);
    }
    for (int i = 0; i < this->lines; i++)
    {
      for (int j = 0; j < this->columns; j++)
      {
        m[i][j] = 0;
      }
    }
  }

  Matrix<T>(const Matrix<T>& original)
  {
    columns = original.getColumns();
    lines = original.getLines();
    T* aux = new T[this->lines * this->columns];
    m = new T*[lines];
    for (int i = 0; i < lines; i++)
    {
      m[i] = aux + (i * this->columns);
    }
    for (int i = 0; i < lines; i++)
    {
      for (int j = 0; j < columns; j++)
      {
        m[i][j] = original.getElement(i, j);
      }
    }
  }

  virtual ~Matrix<T>()
  {
    /*for (int i = lines - 1; i > 0; i--)
    {
      delete m[i];
    }*/
    delete [] m;
  }

  T** getPointer()
  {
    return m;
  }

  int getLines () const
  {
    return lines;
  }

  int getColumns () const
  {
    return columns;
  }

  int getElement(int line, int column)
  {
    return m[line][column];
  }

  int setElement(int line, int column, T value)
  {
    m[line][column] = value;
  }

  Matrix<T>* getTranspose()
  {
    Matrix<T>* aux = new Matrix<T>(lines, columns);
    for (int i = 0; i < lines; i++)
    {
      for (int j = 0; j < columns; j++)
      {
        aux->setElement(i,j, m[j][i]);
      }
    }
    return aux;
  }

  Matrix<T> operator=(const Matrix<T> original)
  {
    columns = original.getColumns();
    lines = original.getLines();
    T* aux = new T[this->lines * this->columns];
    m = new T*[lines];
    for (int i = 0; i < lines; i++)
    {
      m[i] = aux + (i * this->columns);
    }
    for (int i = 0; i < lines; i++)
    {
      for (int j = 0; j < columns; j++)
      {
        m[i][j] = original.getElement(i, j);
      }
    }
  }

  friend std::ostream& operator<<(std::ostream& out, Matrix<T>& matrix)
  {
    out<<"Matrix:"<<std::endl;
    for (int i = 0; i < matrix.getLines(); i++)
    {
      for (int j = 0; j < matrix.getColumns(); j++)
      {
        out<<matrix.getElement(i, j)<<" ";
      }
      out<<std::endl;
    }
    return out;
  }

  friend std::istream& operator>>(std::istream& in, Matrix<T>& matrix)
  {
    std::cout << "Reading Matrix:\n";
    for (int i = 0; i < matrix.getLines(); i++)
    {
      for (int j = 0; j < matrix.getColumns(); j++)
      {
        std::cout << "Matrix[" << i << "][" << j << "]:";
        in >> matrix.m[i][j];
      }
      std::cout << std::endl;
    }
    return in;
  }

 private:
  T** m;
  int lines;
  int columns;
};

正如我可以从该错误中找出的那样，我正在创建 2 个引用同一内存块的对象，但我想创建 2 个引用具有相同内容的不同内存块的 2 个对象。

在你的复制构造函数中

Matrix<T>(const Matrix<T>& original)

original被声明为 const 引用，这非常好。但是，这意味着您不得调用Matrix<T>其上未声明为const功能。

The getElement函数未声明为const所以你不能在复制构造函数中使用它。通过将其声明为 const 函数来解决此问题：

int getElement(int line, int column) const  // <--- Note the 'const'
{
  return m[line][column];
}

这意味着：

1. 这个函数可以被调用Matrixconst 对象（例如original在你的复制构造函数中）

2. 您无法在里面执行任何操作getElement修改当前实例Matrix（即修改*this).

前者是我们想要的，后者不是问题，因为getElement只是一个 getter 方法，所以不需要修改任何东西。

请注意，正因为如此，最好always将成员函数标记为const当他们不应该修改任何东西时。这意味着您可以将它们应用于常量对象，并且意味着编译器会告诉您是否错误地将代码放入实际修改某些内容的函数中。

最后评论：正如托雷·奥尔森 (Tore Olsen) 所指出的，getElement函数应该返回一个对象或类型的引用T而不是int.