C++ 如何计算（A+；B）*（A+；B）？A、 B是矩阵
我有两个练习，一个使用struct，另一个使用class，使用+，*重载来计算矩阵 我的矩阵类型：C++ 如何计算（A+；B）*（A+；B）？A、 B是矩阵,c++,operator-overloading,C++,Operator Overloading,我有两个练习，一个使用struct，另一个使用class，使用+，*重载来计算矩阵 我的矩阵类型： struct matrix { int** a; int m; int n; }; 其中“m”、“n”是行数和列数，“a”是指向将在运行时分配的动态内存的指针 重载的和运算符为：+，*，+=*= 我对两个矩阵都没有问题，包括加法和乘法。但是当我需要显示（A+B）*（A+B）表达式的值时，我会遇到麻烦。注意A+（A*B）是正常的 我试着展示整个表情，似乎是满溢的。然后我声明一个
struct matrix
{
int** a;
int m;
int n;
};
有人能解释我的问题吗？我怎样才能修好它 我使用两个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;
}
A*A工作，但C*C不工作？可能问题不在代码中，而在矩阵的选择中：第一个矩阵中的列数是否等于第二个矩阵中的行数？它必须是矩阵乘法！（在A*A和C*C的情况下，这意味着这些矩阵必须是正方形，除非使用隐式转置。） 如果这不是解决方案，请张贴
- 你的代码
- 你的矩阵
- 您的输出和
- 错误消息/堆栈转储
矩阵温度是一个巨大的警钟。您绝对不应该将其用作重载运算符的一部分
您的运算符+
和运算符*
重载不应返回引用，它们应按值返回矩阵。这将消除在复杂表达式的多个插槽中不可见地重复使用temp
的问题。这会导致观察结果中出现意外值
要使其工作，您需要确保您的矩阵
类是可复制和可分配的。您要么需要使用更高级别的容器，如std:：vector
，以删除所有手动内存管理，要么需要为类提供一个已使用的定义复制构造函数、复制赋值运算符和析构函数
您的手动内存管理当前不正确FreeMatrix
删除mat.a
成员，但不会释放mat.a
元素指向的任何分配数组。此外，检查新表达式是否导致NULL
也是徒劳的<代码>新建
将成功或引发异常
对我来说，我认为最简单的方法是给你的矩阵
一个构造函数，并使用std:：vector
实现它
例如：
结构矩阵
{
矩阵（int m，int n）
：a（std：：vector（m，std：：vector（n，0））；
{
}
std:：vectora；
};
这样，您的矩阵
将是可复制和可分配的，您可以取消AllocMatrix
和FreeMatrix
，并在适当的情况下按值返回矩阵
当然，在切换到向量之前，您需要将*（*（temp.a+i）+j）
等表达式更改为等效的，但可读性更高的temp.a[i][j]
。一些注释：
1：使用成员方法而不是函数
2：不要使用名称空间std
3：如果数组有m个成员，则在for循环中使用<更为传统
for (int i=0; i <= mat.m-1; i++)
// More traditional to use:
for (int i=0; i < mat.m; ++i)
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：删除空对象是可以的，所以在删除之前不要测试空对象
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;
10:在+=函数中。将值求和到一个临时变量中，然后重新分配回mat1。没有理由不这样做
11：每行只声明一个变量
matrix mat1, mat2, mat3;
// All coding standards say use:
matrix mat1;
matrix mat2;
matrix mat3;
原因是它捕捉到了一些与指针相关的问题。在我看来，它还使代码更易于阅读（这也是一个优点）。所有公司都会关注它，所以只要习惯它就行了
12：您的矩阵分配将永远不会失败（如前所述）。它将抛出一个表达式。因此填充将永远不会打印“内存不足”。此外，我要注意的是，您返回的是一个整数，其中bool是指示失败的更好类型（如果您可以指示失败）
任何一个类（或结构）包含指针的代码（分配指针并删除指针）都需要遵守3的规则（另外还要有一个正确的构造函数）
原因是，如果您实际上没有明确禁用它们，编译器将为您生成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.
14：关注点分离
matrix operator +(const matrix &mat1, const matrix &mat2)
{
matrix temp; // add mat1 and mat2 into temp
}
return temp;
matrix mat1, mat2, mat3;
// All coding standards say use:
matrix mat1;
matrix mat2;
matrix mat3;
if (!AllocMatrix(mat1))
{
//
// This will never be executed. EVER.
//
cout << "Out of memory!" << endl;
FreeMatrix(mat1);
return 1;
}
mat3 = mat1 + mat2;
struct matrix
{
int** a;
int m;
int n;
};
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.