c++ - 如何计算 (A + B) * (A + B) ？ A, B 是矩阵

Question

我有2个练习，一个使用结构 和其他用途类(class) , 使用 +, * 重载来计算矩阵。

我的矩阵类型:

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

Answer 1

一些评论:

1:使用成员方法而不是函数
2:不要使用using namespace 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)

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;
}

13:这里有一个潜在的问题。您的代码正在执行 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.

14:关注点分离。

这是一项重要的学习技术。这意味着一个类(class)应该做一件事。它应该包含执行某些业务逻辑的逻辑，或者它应该包含内存管理(或其他管理内容)。它不应该两者都做。

这意味着您的矩阵对象应该专注于执行矩阵运算的逻辑，并将内存管理委托(delegate)给另一种专门为内存管理设计的对象类型。我将其保留为 Charles Bailey在他的回答中详细介绍了这一点。