Question

我正在尝试通过处理重载来学习运算符重载＆gt;＆gt;对于矩阵类，通过调用诸如

之类的函数为矩阵启用基于键盘的输入

Matrix M1;
cin >> M1;

运算符重载部分在下面的

中给出

istream &operator>>(istream &in, Matrix &m) 
{
    for (int i = 0; i < m.dx; ++i)    {
        for (int j = 0; j < m.dy; ++j)
            in >> m.p[i][j];
    }
    return in;
}

我的实施完全不正确。你能告诉我为什么这个实现错了吗？

我通过模仿现有的重载＆gt;＆gt;实现上面的部分，已经证明它在矩阵输出部分工作正常，如cout＆lt;＆lt;一个;其中A是矩阵

ostream &operator<<(ostream &out, const Matrix &m) 
{
    for (int i = 0; i < m.dx; ++i)    {
        for (int j = 0; j < m.dy; ++j)
            out << m.p[i][j] << "  ";
        out << endl;
    }
    return out;
}

Answer 1

我认为您operator >>的问题在于您正在使用Matrix中已经发生的任何维度，而不是尝试从您找到的输入中恢复维度。

我认为您最好的选择是让operator <<实现在矩阵前面加上维度信息（例如行数和列数），然后在该信息中读取operator >>函数。例如：

ostream &operator<<(ostream &out, const Matrix &m) 
{
   out << m.dx << ' ' << out.dy << '\n';
   for (int i = 0; i < m.dx; ++i)    {
      for (int j = 0; j < m.dy; ++j)
        out << m.p[i][j] << "  ";
      out << endl;
   }
   return out;
 }

有了这个，您可以将您的流提取操作符编写为

istream &operator>>(istream &in, Matrix &m) 
{
   in >> m.dx >> m.dy;

   /* Some sort of logic to ensure that you've allocated an array large enough to
    * hold all the elements ...
    */

   for (int i = 0; i < m.dx; ++i)    {
       for (int j = 0; j < m.dy; ++j)
           in >> m.p[i][j];
   }
   return in;
}

这可能不是最美观的输入和输出操作员，但他们应该完成工作。

如果要使这些运算符有点分类，可以考虑使用一些特殊字符输出矩阵的元素来分隔行和列。例如，您可以尝试输出矩阵

0 1 2
3 4 5
6 7 8

作为

[[0 1 2][3 4 5][6 7 8]]

使用此设置，有关矩阵的大小信息隐含在括号分组的工作方式中。然后，这可能会使读取输入变得有点棘手，因为您事先不知道矩阵有多大。但总的来说，最简单的事情就是这样。

作为一个FYI，您可能不希望在编写流插入运算符时使用endl来分隔行。除了编写换行符之外，endl还会刷新缓冲区。如果您的流连接到网络连接，您可能不希望在有新的矩阵行时继续刷新缓冲区，因为这可能导致大量数据以突发形式发送（慢速）而不是对其进行分组所有在一起（快速）。

希望这有帮助！

Answer 2

我认为你的代码不是特别错误。如果按下，我建议检查循环中的流状况。为了您的信息，以下代码在我测试时起作用：

struct Matrix {
    static int const dx = 2, dy = 2;
    int p[ dx ][ dy ];
};

istream &operator>>(istream &in, Matrix &m) 
{
   for (int i = 0; i < m.dx; ++i)    {
       for (int j = 0; j < m.dy; ++j)
           if ( ! (in >> m.p[i][j]) ) return in;
 }
 return in;
}

int main() {
    Matrix M1;
    cin >> M1;
    cout << M1;
}

希望这有帮助

Answer 3

#include<iostream>

using namespace std;

class Array /*overload of subscript operator of 1D array*/
{
     private: int *p;
     public:
          int length;
          Array(int size = 0): length(size)
          {
                p=new int(length);
          }
          int& operator [](const int k)
          {
               return p[k];
          }
};
class Matrix
{
      private: Array *p;
      public: 
            int r,c;
            Matrix(int i=0, int j=0):r(i), c(j)
            {
                 p= new Array[r];
            }
            Array& operator [](const int& i)
            {
                 return p[i];
            }
            friend istream& operator >> (istream& in, Matrix& m);
          /*friend ostream& operator << (ostream& out, Matrix& m);*/
};
istream& operator >> (istream& in, Matrix& m)
{
     for(int i=0 ; i < m.r ; i++)
     {
         for(int j=0 ; j < m.c ; j++)
               in >> m[i][j];
     }
}
/*ostream& operator << (ostream& out, Matrix& m)
{
     for(int i=0 ; i < m.r ; i++)
     {
         for(int j=0 ; j < m.c ; j++)
               out << m[i][j] << " ";
         out << endl;
     }
}*/

/*Driver program*/
int main()
{
    Matrix M1(3,3); /*for checking purpose*/
    cin >> M1;
  /*cout << "\n" << M1;*/
}

麻烦重载运算符＆gt;＆gt;对于矩阵类

3 个答案: