C++程序设计实验报告(六十)---第九周任务4

/* (程序头部注释开始)
* 程序的版权和版本声明部分
* Copyright (c) 2012, 烟台大学计算机学院学生 
* All rights reserved.
* 文件名称：流运算符重载运算符（二维数组类Douary）

* 作 者： 刘镇
* 完成日期： 2012 年 4 月 15 日
* 版 本 号： 1.056
* 对任务及求解方法的描述部分
* 输入描述： 二维数组

* 问题描述： 流运算符重载

* 程序输出： ......

* 程序头部的注释结束
*/

#include <iostream>    

using namespace std;    

class Douary    
{    
public:    
	Douary(int m, int n);//构造函数：用于建立动态数组存放m行n列的二维数组（矩阵）元素，并将该数组元素初始化为    
	~Douary(); //析构函数：用于释放动态数组所占用的存储空间。    
	friend istream &operator>>(istream &input, Douary &d);//重载运算符“>>”输入二维数组，其中d为Dousry类对象；    
	friend ostream &operator<<(ostream &output, Douary &d);//重载运算符“<<”以m行n列矩阵的形式输出二维数组，其中d为Douary类对象。    
	friend Douary &operator+(const Douary &d1,const Douary &d2);//两个矩阵相加，规则：对应位置上的元素相加    
	friend Douary &operator-(const Douary &d1,const Douary &d2);//两个矩阵相减，规则：对应位置上的元素相减    
	bool operator==(const Douary &d);//判断两个矩阵是否相等，即对应位置上的所有元素是否相等    
private:    
	int *Array;      //Array 为动态数组指针。    
	int row;          //row  为二维数组的行数。    
	int col;          //col   为二维数组的列数。    
};    

Douary::Douary(int m, int n)    
{    
	row = m;    
	col = n;   
	Array = new int[row*col];  

	for(int i = 0; i < row*col; ++i)    
	{    
		*(Array + i) = 0;  
	}  

}    

Douary::~Douary()  
{  
	delete[]Array;  
}  

istream &operator >> (istream &input, Douary &d)    
{    
	for(int i = 0; i < d.row; ++i)    
	{    
		for(int j = 0; j < d.col; ++j)    
		{    
			input >> d.Array[d.row * i + j] ;  
		}    
	}    
	return input;    
}    

ostream &operator << (ostream &output, Douary &d)    
{    
	for(int i = 0; i < d.row; ++i)    
	{    
		for(int j = 0; j < d.col; ++j)    
		{    
			output << d.Array[d.row * i + j]<< " ";    
		}    
		cout << endl;    
	}    

	return output;    
}    

Douary &operator + (const Douary &d1,const Douary &d2)    
{    
	Douary *p = new Douary(d1.row, d1.col);  

	for(int i = 0; i < d1.row; ++i)    
	{    
		for(int j = 0; j < d1.col; ++j)    
		{    
			(*p).Array[d1.row * i + j] = d1.Array[d1.row * i + j] + d2.Array[d1.row * i + j];    
		}    
	}    

	return (*p);    
}    

Douary &operator - (const Douary &d1,const Douary &d2)    
{    
	Douary *p = new Douary(d1.row, d1.col);

	for(int i = 0; i < d1.row; ++i)    
	{    
		for(int j = 0; j < d1.col; ++j)    
		{    
			(*p).Array[d1.row * i + j] = d1.Array[d1.row * i + j] - d2.Array[d1.row * i + j];    
		}    
	}    

	return (*p); 
}    

bool Douary::operator == (const Douary &d)    
{       

	for(int i = 0; i < row; ++i)    
	{    
		for(int j = 0; j < col; ++j)    
		{    
			if(Array[d.row * i + j] != d.Array[d.row * i + j])    
			{    
				return false;    

				break;    
			}    
		}    
	}    

	return true;    
}    

int main()    
{    
	Douary d1(2,3),d2(2,3);    

	cout << "输入d1:" << endl;    
	cin >> d1;    

	cout << "输入d2:" << endl;    
	cin >> d2;    

	cout << "d1=" << endl;    
	cout << d1;    

	cout << "d2="  <<endl;    
	cout << d2;    

	cout << "d1+d2=" << endl;    
	cout << (d1+d2);    

	cout << "d1-d2=" << endl;    
	cout << (d1-d2);    

	cout << "d1" << ((d1==d2)?"==":"!=") << "d2" << endl;    

	system("pause");    

	return 0;    
}

对于老师给出的整理结果：

#include <iostream>    
    
using namespace std;    
    
class Douary    
{    
public:    
    Douary(int m, int n);//构造函数：用于建立动态数组存放m行n列的二维数组（矩阵）元素，并将该数组元素初始化为    
    ~Douary(); //析构函数：用于释放动态数组所占用的存储空间。    
    Douary(const Douary &d);//构造函数：用于建立动态数组存放m行n列的二维数组（矩阵）元素，并将该数组元素初始化为  
	friend istream &operator>>(istream &input, Douary &d);//重载运算符“>>”输入二维数组，其中d为Dousry类对象；    
    friend ostream &operator<<(ostream &output, Douary &d);//重载运算符“<<”以m行n列矩阵的形式输出二维数组，其中d为Douary类对象。    
    friend Douary operator+(const Douary &d1,const Douary &d2);//两个矩阵相加，规则：对应位置上的元素相加    
    friend Douary operator-(const Douary &d1,const Douary &d2);//两个矩阵相减，规则：对应位置上的元素相减    
    bool operator==(const Douary &d);//判断两个矩阵是否相等，即对应位置上的所有元素是否相等    
private:    
    int *Array;      //Array 为动态数组指针。    
    int row;          //row  为二维数组的行数。    
    int col;          //col   为二维数组的列数。    
};    
  
Douary::Douary(int m, int n)    
{    
    row = m;    
    col = n;   
    Array = new int[col * row];  
       
    for(int i = 0; i < row; ++i)  
	{
		for(int j = 0; j < col; ++j)  
		{
			Array[i * col + j]=0;
		}
	}
  
}    

Douary::Douary(const Douary &d)  
{  
    row = d.row;  
    col = d.col;  

    Array = new int[row*col];  

    for(int i = 0; i < row; ++i)  
	{
		for(int j = 0; j < col; ++j)  
		{
			Array[i * col + j] = d.Array[i * col + j]; 
		}
	}
}  
  
Douary::~Douary()  
{  
    delete[]Array;  
}  
    
istream &operator >> (istream &input, Douary &d)    
{    
    for(int i = 0; i < d.row; ++i)  
	{
		for(int j = 0; j < d.col; ++j)  
		{
            input >> d.Array[i * d.col+j] ;  
         }    
    }    
    return input;    
}    
    
ostream &operator << (ostream &output, Douary &d)    
{    
    for(int i = 0; i < d.row; ++i)  
	{
		for(int j = 0; j < d.col; ++j)  
		{
            output << d.Array[i * d.col+j]<< " ";    
        }    
        cout << endl;    
    }    
    
    return output;    
}    

Douary operator + (const Douary &d1,const Douary &d2)    
{    
    Douary d(d1.row, d1.col);  
  
    for(int i = 0; i < d1.row; ++i)  
	{
		for(int j = 0; j < d1.col; ++j)  
		{ 
            d.Array[i * d1.col + j] = d1.Array[i * d1.col + j] + d2.Array[i * d1.col + j];    
        }    
    }    
    
    return d;    
}    
    
Douary operator - (const Douary &d1,const Douary &d2)    
{    
    Douary d(d1.row,d1.col); 
  
    for(int i = 0; i < d1.row; ++i)  
	{
		for(int j = 0; j < d1.col; ++j)  
		{ 
            d.Array[i * d1.col + j] = d1.Array[i * d1.col + j] - d2.Array[i * d1.col + j];    
        }    
    }    
    
    return d; 
}  
    
bool Douary::operator == (const Douary &d)    
{       
    for(int i = 1; i <= row; ++i)    
    {    
        for(int j = 1; j <= col; ++j)    
        {    
            if(Array[i * d.col + j] != d.Array[i * d.col + j])    
            {    
                return false;    
    
                break;    
            }    
        }    
    }    
    
    return true;    
}    
    
int main()    
{    
    Douary d1(2,3),d2(2,3);    
    
    cout << "输入d1:" << endl;    
    cin >> d1;    
    
    cout << "输入d2:" << endl;    
    cin >> d2;    
    
    cout << "d1=" << endl;    
    cout << d1;    
    
    cout << "d2="  <<endl;    
    cout << d2;    
    
    cout << "d1+d2=" << endl;    
    cout << (d1+d2);    
    
    cout << "d1-d2=" << endl;    
    cout << (d1-d2);    
    
    cout << "d1" << ((d1==d2)?"==":"!=") << "d2" << endl;    
    
    system("pause");    
    
    return 0;    
}   

运行结果：

 

感言：

 

1、在二维数组的一维数组表示上遇到了麻烦，主要是在思想上怎样理解一维数组和二维间的内存上了联系。

2、处理重载的返回值问题！

3、为什么对于循环的处理如i= 0和i = 1进行的循环结果有大错！