设计方阵类Square，其结构如下：

class Square{

 private:

        int n;                                                                    //方阵的行列数

        int *data;                                                             //用于存放方阵n*n个数据的数据区

public:

        Square(int m);                                                    //m是行列数，将方阵的每个数据设置为0

        Square(int m, int *d);                                          //m是行列数，d是指向初始化数据区的指针

        Square operator *(const Square & );                 //重载矩阵*运算符

        Square operator =(const Square &);                 //重载矩阵=运算符

        void print();                                                        //显示矩阵的内容

};

void Square::print()

{

        int i,j;

        for(i = 0; i < n; i++)

        {

                 for(j =0; j < n; j++)

                         cout << data[i*n+j] << " ";

                 cout << endl;

        }

}

main函数

int main( )

{

        int d1[5][5] = {{1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5},{1,9,3,4,5},{1,2,3,4,5}};

        int d2[5][5] = {{5,4,3,2,1},{1,4,3,2,1},{5,4,3,2,1},{5,4,3,2,1},{2,4,7,2,1}};

        Square a(5,(int *)d1),b(5,(int *)d2),c(5);

        c = a * b;

        c.print();

}

矩阵乘法规则：

矩阵与矩阵相乘 第一个矩阵的列数一必须等于第二个矩阵的行数 假如第一个是m*n的矩阵 第二个是n*p的矩阵 则结果就是m*p的矩阵 且得出来的矩阵中元素具有以下特点：
第一行第一列元素为第一个矩阵的第一行的每个元素和第二个矩阵的第一列的每个元素乘积的和 以此类推 第i行第j列的元素就是第一个矩阵的第i行的每个元素与第二个矩阵第j列的每个元素的乘积的和。

代码如下：

using namespace std;
#include<iostream>

class Square{
private:
	int n; 
	int *data;
public:
	Square(int m);          
	Square(int m, int *d);   
	Square operator *(const Square &d);  
	Square operator =(const Square &d); 
	void print();                       
};
Square::Square(int m){
	n=m;
	data=new int[n*n];
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<n;j++)
		{
			data[i*n+j]=0;
		}
	}
}
Square::Square(int m,int *d){                    /*存在指针，需要深拷贝*/
	n=m;
	data=new int[n*n];                           /*重新定义一块内存用来存放数据*/
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<n;j++)
		{
			data[i*n+j]=d[i*n+j];
		}
	}
}
Square Square::operator *(const Square &d){      /*重载运算符 * */
	int* temp=new int[d.n*d.n];                  
	int count=0;
	for (int i=0;i<n;i++) 
	{
		for(int j=0;j<n;j++)
		{
			for(int k=0;k<n;k++)
			{
				count+=data[i*n+k]*(d.data[k*n+j]);
			}	
			temp[i*n+j]=count;
			count=0;
		}
	}
	return Square(n, temp);
}
Square Square::operator =(const Square &d){      /*重载运算符 = */
	n=d.n;
	data = new int[n*n];
	for (int i = 0;i<n*n;i++) 
		data[i] = d.data[i];
	return *this;
}
void Square::print(){
	int i,j;
	for(i = 0; i < n; i++)
	{
		for(j =0; j < n; j++)
			cout << data[i*n+j] << " ";
		cout << endl;
	}
}

int main( )
{
	int d1[5][5] = {{1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5},{1,9,3,4,5},{1,2,3,4,5}};
	int d2[5][5] = {{5,4,3,2,1},{1,4,3,2,1},{5,4,3,2,1},{5,4,3,2,1},{2,4,7,2,1}};
	Square a(5,(int *)d1),b(5,(int *)d2),c(5);
	c = a * b;
	c.print();
}

运算结果：

 小结：

这道题目的难点之一就是，搞懂矩阵的乘法规则，逐行逐列逐项的去相乘。其次就是要注意，在有指针的情况下，拷贝构造函数需要深拷贝，否则会报错。重载运算符的话，并不是很难，注意重载=时，返回自身*this。