我有2个练习，一个使用结构，另一个使用类，使用+，*重载来计算矩阵。
我的矩阵类型：
struct matrix
{
int** a;
int m;
int n;
};
“m”，“n”是行数和列数，“a”是指向指针的指针，它将是在运行时分配的动态内存。
重载的运算符是：+，*，+ =，* =
我对2个矩阵没有问题，包括加法和乘法。但是当我需要显示（A + B）*（A + B）表达式的值时，我遇到了麻烦。请注意，A +（A * B）没问题。
我尝试显示整个表达式，似乎是溢出的。然后我声明一个矩阵类型C，指定C = A + B，C是正确的。但是如果我显示C * C，结果仍然相同，非常糟糕，尽管A * A很好。
有人可以解释我的问题吗？我该如何解决？
我用两个4x4矩阵进行测试，它们的元素从1到16编号。
我的代码：
#include <iostream>
using namespace std;
struct matrix
{
int** a;
int m;
int n;
};
matrix temp;
matrix InputMatrix(matrix &mat)
{
for (int i=0; i <= mat.m-1; i++)
{
for (int j=0; j <= mat.n-1; j++)
{
cout.width(5);
cout << "[" << i+1 << "," << j+1 << "] = ";
*(*(mat.a + i) + j) = i*mat.m + j + 1;
cout << *(*(mat.a + i) + j);
/*int x = rand()%20; // random matrix
cout << x;
*(*(mat.a + i) + j) = x;*/
}
cout << endl;
}
return mat;
}
int AllocMatrix(matrix &mat)
{
mat.a = new int*[mat.m];
if (mat.a == NULL)
{
return 0;
}
for (int i=0; i <= mat.m-1; i++)
{
*(mat.a + i) = new int[mat.n];
if (*(mat.a + i) == NULL)
{
return 0;
}
}
return 1;
}
int FreeMatrix(matrix &mat)
{
if (mat.a != NULL)
{
delete [] mat.a;
}
return 0;
}
int DispMatrix(const matrix &mat)
{
for (int i=0; i <= mat.m-1; i++)
{
for (int j=0; j<= mat.n-1; j++)
{
cout.width(7);
cout << *(*(mat.a + i) + j);
}
cout << endl;
}
cout << endl;
return 0;
}
matrix & operator +(const matrix &mat1, const matrix &mat2)
{
for (int i=0; i <= temp.m-1; i++)
{
for (int j=0; j <= temp.n-1; j++)
{
*(*(temp.a + i) + j) = *(*(mat1.a + i) + j) + *(*(mat2.a + i) + j);
}
}
return temp;
}
matrix & operator +(const matrix &mat1, const int k)
{
for (int i=0; i <= temp.m-1; i++)
{
for (int j=0; j <= temp.n-1; j++)
{
*(*(temp.a + i) + j) = *(*(mat1.a + i) + j) + k;
}
}
return temp;
}
matrix & operator +=(matrix &mat1, const matrix &mat2)
{
for (int i=0; i <= mat1.m-1; i++)
{
for (int j=0; j <= mat1.n-1; j++)
{
*(*(temp.a + i) + j) = *(*(mat1.a + i) + j) + *(*(mat2.a + i) + j);
}
}
for (int i=0; i <= temp.m-1; i++)
{
for (int j=0; j <= temp.n-1; j++)
{
*(*(mat1.a + i) + j) = *(*(temp.a + i) + j);
}
}
return mat1;
}
matrix & operator *(const matrix &mat1, const matrix &mat2)
{
for (int i=0; i <= mat1.m-1; i++)
{
for (int j=0; j <= mat2.n-1; j++)
{
int tong = 0;
for (int k=0; k <= mat2.m-1; k++)
{
tong += (*(*(mat1.a + i) + k)) * (*(*(mat2.a + k) + j));
}
*(*(temp.a + i) + j) = tong;
}
}
return temp;
}
matrix & operator *(const matrix &mat1, const int k)
{
for (int i=0; i <= temp.m-1; i++)
{
for (int j=0; j <= temp.n-1; j++)
{
*(*(temp.a + i) + j) = *(*(mat1.a + i) + j) * k;
}
}
return temp;
}
matrix & operator *=(matrix &mat1, const matrix &mat2)
{
for (int i=0; i <= mat1.m-1; i++)
{
for (int j=0; j <= mat2.n-1; j++)
{
int tong = 0;
for (int k=0; k <= mat2.m-1; k++)
{
tong += (*(*(mat1.a + i) + k)) * (*(*(mat2.a + k) + j));
}
*(*(temp.a + i) + j) = tong;
}
}
for (int i=0; i <= temp.m-1; i++)
{
for (int j=0; j <= temp.n-1; j++)
{
*(*(mat1.a + i) + j) = *(*(temp.a + i) + j);
}
}
return mat1;
}
int main()
{
matrix mat1, mat2, mat3;
int m1 = 0, n1 = 0, m2 = 0, n2 = 0;
m1 = m2 = n1 = n2 = 4;
mat1.m = m1;
mat1.n = n1;
mat2.m = m2;
mat2.n = n2;
mat3.m = m1;
mat3.n = n1;
AllocMatrix(mat3);
if (!AllocMatrix(mat1))
{
cout << "Out of memory!" << endl;
FreeMatrix(mat1);
return 1;
}
if (!AllocMatrix(mat2))
{
cout << "Out of memory!" << endl;
FreeMatrix(mat1);
FreeMatrix(mat2);
return 1;
}
cout << "Matrix - 1:" << endl;
mat1 = InputMatrix(mat1);
cout << "Matrix - 2:" << endl;
mat2 = InputMatrix(mat2);
if ((mat1.m == mat2.m)&&(mat1.n == mat2.n))
{
temp.m = mat1.m;
temp.n = mat1.n;
if (!AllocMatrix(temp))
{
cout << "Out of memory!" << endl;
FreeMatrix(mat1);
FreeMatrix(mat2);
FreeMatrix(temp);
return 1;
}
cout << "Ressult: " << endl;
mat3 = mat1 + mat2;
DispMatrix(mat3);
DispMatrix(mat3 * mat3);
FreeMatrix(temp);
}
FreeMatrix(mat1);
FreeMatrix(mat2);
system("pause");
return 0;
}
结果：
Matrix - 1:
[1,1] = 1 [1,2] = 2 [1,3] = 3 [1,4] = 4
[2,1] = 5 [2,2] = 6 [2,3] = 7 [2,4] = 8
[3,1] = 9 [3,2] = 10 [3,3] = 11 [3,4] = 12
[4,1] = 13 [4,2] = 14 [4,3] = 15 [4,4] = 16
Matrix - 2:
[1,1] = 1 [1,2] = 2 [1,3] = 3 [1,4] = 4
[2,1] = 5 [2,2] = 6 [2,3] = 7 [2,4] = 8
[3,1] = 9 [3,2] = 10 [3,3] = 11 [3,4] = 12
[4,1] = 13 [4,2] = 14 [4,3] = 15 [4,4] = 16
Ressult:
2 4 6 8
10 12 14 16
18 20 22 24
26 28 30 32
360 1832 28180 708768
43888039688236210260317821152
95260335311192-6444114522130541536
2990856-14161730721164069912-1507182592
答案 0 :(得分：4)
命名空间范围内的这个定义matrix temp;是一个巨大的警钟。您绝对不应该将此作为重载运算符的一部分使用。
您的operator+和operator*重载不应返回引用，它们应按值返回matrix。这将消除在复杂表达式的多个槽中无形地重复使用temp的问题。这会导致观察结果出现意外值。
要使此功能正常工作，您需要确保matrix类可以复制和分配。您需要使用更高级别的容器（例如std::vector）来删除所有手动内存管理，或者您需要为您的类提供使用定义的复制构造函数，复制赋值运算符和析构函数。
您的手动内存管理目前不正确。 FreeMatrix删除mat.a成员，但它不会释放mat.a元素所指向的任何已分配数组。此外，检查new表达式是否导致NULL是徒劳的。 new将成功或抛出异常。
对我来说，我认为最简单的方法是给你的matrix构造函数并使用std::vector实现它。
E.g：
struct matrix
{
matrix( int m, int n )
: a( std::vector< std::vector<int> >( m, std::vector<int>( n, 0 ) );
{
}
std::vector< std::vector<int> > a;
};
这样，您的matrix将是可复制和可分配的，您可以取消AllocMatrix和FreeMatrix，并在适当的时候按值返回matrix。
当然，在转换为*(*(temp.a + i) + j)之前，您需要将temp.a[i][j]之类的表达式更改为等效，但更具可读性vector。
答案 1 :(得分：4)
一些意见：
1：使用成员方法而不是函数
2：不要使用using namespace std
3：如果一个数组有m个成员，那么使用＆lt;在for循环中。
for (int i=0; i <= mat.m-1; i++)
// More traditional to use:
for (int i=0; i < mat.m; ++i)
4：使用比i更长的变量名称。尝试在代码中搜索变量“i”的所有实例。你会得到很多误报。像loopM这样的东西会更容易阅读。
5：使用[]运算符
*(*(mat.a + i) + j) = BLA;
// Cab be written as:
mat.a[i][j] = BLA;
6：在正常情况下，new永远不会返回NULL。所以不要编写检查它的代码。如果失败则会抛出异常。这允许您从正常的代码流中删除错误检测代码并处理异常中的错误。
mat.a = new int*[mat.m];
// This is a waste of time. Here mat.a will NEVER be NULL
if (mat.a == NULL)
{
return 0;
}
7：删除NULL对象是可以的。所以不要在删除之前测试NULL。
if (mat.a != NULL)
{
delete [] mat.a;
}
// If it is NULL nothing bad will happen.
delete [] mat.a
8：你忘了删除所有成员 注意：如果您使用了构造函数/析构函数，我会更有信心这是正确的，因为编译器将保证如果构造函数抛出异常，则不会调用析构函数。另一方面，您对函数的使用并不能保证这一点，您可能会捕获异常并仍在无效的矩阵对象上执行FreeMatrix（）。但由于您当前的代码没有异常处理，我觉得它很安全。
for(int loop = 0;loop < m;++loop)
{
delete [] mat.a[loop];
}
delete [] mat.a;
9：您的操作员+似乎使用了一些随机的临时变量？
更喜欢在函数内声明temp并返回副本。但要实现这一点，您需要正确的复制构造函数和赋值运算符（见下文）。
matrix operator +(const matrix &mat1, const matrix &mat2)
{
matrix temp; // add mat1 and mat2 into temp
}
return temp;
10：在你的+ =功能中。将值加总为临时变量，然后重新分配回mat1。没有理由不这样做。
11：每行只声明一个变量。
matrix mat1, mat2, mat3;
// All coding standards say use:
matrix mat1;
matrix mat2;
matrix mat3;
原因是它捕获了与指针相关的几个问题。在我看来，它也使代码更容易阅读（这也是一个加号）。所有的比较都会对它产生影响，所以只要习惯它。
12：你的矩阵分配永远不会失败（如前所述）。它会引发一场爆炸。因此，填充将永远不会打印“内存不足”。另外我会注意到你返回一个整数，其中bool是一个更好的类型来指示失败（如果你可能已经指出失败）。
if (!AllocMatrix(mat1))
{
//
// This will never be executed. EVER.
//
cout << "Out of memory!" << endl;
FreeMatrix(mat1);
return 1;
}
operator +。但它也在执行matrix::operator=。您没有定义此，但编译器自动生成此方法的代码。它并没有按照你的想法行事。幸运的是，你没有释放mat3因此它没有爆炸。
mat3 = mat1 + mat2;
任何代码，其中类（或结构）包含由（您分配指针并删除它们）指针的指针，需要遵守3的规则（加上具有正确的构造函数）。
struct matrix
{
int** a;
int m;
int n;
};
原因是如果你实际上没有特别禁用它们，编译器将为你生成4种方法。如果您开始手动分配/删除内存，这些方法中的两个（复制构造和赋值运算符）将执行使您的释放难以正确执行的操作。因此，您应该禁用它们或显式定义所有4个编译器生成的方法。
在您的情况下，编译器会生成以下4种方法：
matrix::matrix() { /* Do nothing or value initialize */ }
matrix::~matrxc(){ /* Do nothing */ }
matrix::matrix(matrix const& rhs)
: a(rhs.a)
, m(rhs.m)
, n(rhs.n)
{}
matrix& matrix::operator+(matrix const& rhs)
{
a = rhs.a;
m = rhs.m;
n = rhs.n;
return *this;
}
现在考虑以下代码将执行的操作：
matrix m1;
m1.m = 5;
m1.n = 5;
AllocMatrix(m1));
matrix m2;
m2.m = 5;
m2.n = 5;
AllocMatrix(m2));
m2 = m1; /* Simplified version of m3 = m1 + m2; */
// The problem is that the a member is being copied from m1 to m2.
// But the copy is a shallow copy. So now both m1 and m2 point at the same
// piece of memory.
FreeMatrix(m2); // Frees m2.a
FreeMatrix(m1); // Whops. This Frees m1.a but it points at the same memory as m2.a
// So now you have a double delete.
这是一项重要的学习技巧。这意味着一个班级应该做一件事。它应该包含执行某些业务逻辑的逻辑，或者应该包含内存管理（或其他管理内容）。它不应该两者兼而有之。
这意味着您的矩阵对象应该专注于执行矩阵操作的逻辑，并将内存管理委托给另一个专门用于内存管理的对象类型。我将把它留在那里，因为Charles Bailey在他的回答中详细介绍了这一点。
答案 2 :(得分：0)
A * A有效，但C * C没有？也许问题不在你的代码中，而是在矩阵的选择中：第一个矩阵中的列数是否等于第二个矩阵中的行数？它必须是矩阵乘法！ （在A * A和C * C的情况下，除非你使用隐式换位，否则这些矩阵必须是正方形。）
如果这不是解决方案，请发布