Question

我编写了一个将矩阵提升到一定功率的函数。但是在运行代码时，结果是内存位置而不是实际值。我认为问题在于指针。

我的代码：

#include <iostream>

using namespace std;

typedef int array2d [2][2];
array2d A,B,r;

void pow(array2d* r,array2d C);

int main(){
array2d resa,resb;


A[0][0]=2;
A[0][1]=2;
A[1][0]=2;
A[1][1]=2;

B[0][0]=3;
B[0][1]=3;
B[1][0]=3;
B[1][1]=3;

r[0][0]=1;
r[0][1]=0;
r[1][0]=0;
r[1][1]=1;

pow(&resa,A);

for(int i=0;i<2;i++){
  for(int j=0;j<2;j++)
   {
cout<<resa[i][j]<<" ";
}
cout<<endl;
}

pow(&resb,B);

for(int i=0;i<2;i++){
  for(int j=0;j<2;j++)
   {
cout<<resb[i][j]<<" ";
}
cout<<endl;
}

return 0;
}

void pow(array2d* r, array2d C)
{
array2d temp;

for(int w=0;w<3;w++)
    {
        for(int i=0;i<2;i++){
        for(int j=0;j<2;j++)
        {
        temp[i][j]=0;   
        for(int k=0;k<2;k++)
        temp[i][j]+=(*r)[i][k]*C[k][j];
        }}

for(int i=0;i<2;i++){
  for(int j=0;j<2;j++)
   {
    (*r)[i][j]=temp[i][j];
    }}
}
}

我该如何解决这个问题。

谢谢。

Answer 1

您的错误与指针或地址无关，但您的算法错误：

pow(&resa, A);

将矩阵A与未初始化的矩阵resa相乘，这可以产生任意数量的可能结果。

快速而肮脏的修复方法是将resa和resb初始化为标识矩阵：

array2d resa = { { 1, 0 }, { 0, 1 } };
array2d resb = { { 1, 0 }, { 0, 1 } };

编辑或稍好一点：在pow内部初始化r

//passing r by pointer is not actually necessary here,
//but I don't want to modify too much of the code
(r*)[0][0] = 1; 
(r*)[1][0] = 0;
(r*)[0][1] = 0;
(r*)[1][1] = 1;

更优雅的解决方案是首先将参数C与自身相乘，将结果存储在r中，然后继续算法。

旁注：如果不需要，请不要使用c风格的数组（尤其不要在typedef中）。请改用std::array，这将消除大部分关于参数传递的困惑。

Answer 2

pow函数的第一个参数，将其更改为引用传递：void pow(array2d &r,array2d C);

然后你在哪里调用它，就像这样调用它：pow(resa,A);

最后，您现在不需要在功能中使用r，因此(*r)[i][j]=temp[i][j];可以更改为r[i][j]=temp[i][j];

我认为这就是你想要做的。（通过引用传递）

（我现在不在我可以测试它的电脑前面，我会尽快确认，也许可以充实为什么这更好（可以阅读有关指针，堆内存和通过引用传递）

Answer 3

你应该尽可能避免全局，并且在全局和局部变量中使用相同的名称会更糟糕

也是变量MATTERS的名称，这里我称输入矩阵IN和输出矩阵OUT（ok＆＃34; n＆＃34;应称为幂）

using namespace std;

typedef int array2d [2][2];

void display( array2d a ) ;

void pow(array2d IN ,array2d OUT , int  n);


int main()
{
    array2d A,B;
    array2d resa,resb;

    A[0][0]=2;
    A[0][1]=2;
    A[1][0]=2;
    A[1][1]=2;

    B[0][0]=3;
    B[0][1]=1;
    B[1][0]=2;
    B[1][1]=1;

    pow (A , resa , 5);

    pow( B , resb, 2 ) ;

    return 0;
}

和

void pow(array2d IN, array2d OUT , int n )
{
    for( int i = 0 ; i < 2 ; ++ i )
        for( int j = 0 ; j < 2 ; ++ j )
            OUT[i][j] = ( i == j ) ;

    display( OUT ) ;    

    array2d temp;

    for(int w=0;w<n;w++)
    {
        for(int i=0;i<2;i++)
        {
            for(int j=0;j<2;j++)
            {
                temp[i][j]=0;   
                for(int k=0;k<2;k++)
                {
                    temp[i][j]+=OUT[i][k]*IN[k][j];
                }
            }
        }

        for(int i=0;i<2;i++){
            for(int j=0;j<2;j++)
            {   
                OUT[i][j]=temp[i][j];
            }
        }
        display( OUT ) ;
    }
}

带

void display( array2d a )
{
    cout << endl ;
    for( int i = 0 ; i < 2 ; ++ i )
    {
        for( int j = 0 ; j < 2 ; ++ j )
            cout << a[i][j] << " " ;
        cout << endl ;
    }
}

提升矩阵为C ++提供动力

3 个答案: