0

我正在尝试编写一个通用矩阵转置函数

void reverse(int** v , int vertexes )
{
    for(int i=0;i<vertexes;i++)
        for(int j=0;j<vertexes;j++) 
        {
            if(v[i][j] == 1 && v[j][i]==0){
                v[j][i] = -1;
                v[i][j] = 0;        
            }
        }

    for(int i=0;i<vertexes;i++)
        for(int j=0;j<vertexes;j++) 
        {
            if(v[i][j] == -1 )
                v[i][j] = 1;
        }
}

主要功能是

void matrix_graph::process()
{

    int v[7][7] = {
        {0,1,0,0,0,0,0},
        {0,0,1,1,0,0,0},
        {1,0,0,0,0,0,0}, 
        {0,0,0,0,1,0,0},
        {0,0,0,0,0,1,0},
        {0,0,0,1,0,0,1},
        {0,0,0,0,0,1,0}
    };

    reverse(v,7);
}

我果然得到了一个

error C2664: 'reverse' : cannot convert parameter 1 from 'int [7][7]' to 'int **'

我们能做些什么吗？

是我们可以做的最好的访问i,j传递的二维数组（v作为一维数组传递）是

v[vertexes*i][j]
4

5 回答 5

5

只需使用

void reverse(int vertexes, int v[vertexes][vertexes])

尝试使用int **不会立即与内置二维数组一起使用。如果你想坚持int **接口，那么你将不得不创建一个额外的临时行索引数组，如此处所述

通过指针传递二维数组

或在这里

将二维数组转换为指针到指针

于 2013-06-22T17:22:29.090 回答
3

您应该小心，因为数组数组与双指针不同。虽然数组确实会衰减为指针，但将指向指针的指针用作数组数组意味着您实际上将其用作指针数组。

而是将参数作为指向数组的指针，例如

int (*v)[7]
于 2013-06-22T17:17:11.593 回答
0

我认为使用堆内存可以解决这个问题。因此，不是int[7][7] v在堆栈中声明，而是使用 malloc 将在堆中创建数组并允许您在函数之外对其进行操作。

int** v = (int**)malloc((sizeof(int*) * 7));

for (int i = 0; i < 7; i++)
{
    v[i] = (int*)malloc(sizeof(int)*7);
}
// then initialize v here...
于 2013-06-22T17:17:18.547 回答
0

要摆脱错误并保持您的想法，您可以按如下方式调用您的函数：

reverse(&v[0][0],7);

并修改函数和原型：

void reverse(int* v , int vertexes ){
for (int i=0; i<vertexes; i++)
    for (int j=0; j<vertexes; j++){
    // do stuff 
    v[i*vertexes+j]; //equivalent of v[i][j]
    v[j*vertexes+i]; //equivalent of v[j][i]
}
于 2013-06-22T17:27:05.617 回答
0

我想这里一个好的设计是创建一个Matrix封装矩阵上的操作的类。我还建议不要使用指针来存储矩阵的数据，而是使用一维数组和索引转换，例如：

int &Matrix::at( int i, int j )
{
    // check the constraints
    return m_array[i * m_width + j];
}

这简化了内存管理并防止在处理不必要的复杂构造时处理错误。

C/C++ 中的多维数组与指向指针的指针指向...指向指针的指针不同。多维数组实际上是一个连续的内存区域，由编译器完成索引转换，而指针指针是指向其他维度的指针的一维数组。在这种情况下，内存可能不是连续的，并且在这种情况下还有额外的指针，在多维数组的情况下不存在。

总结一下，如果是数组：

int array[7][7] = { ... };
array[2][3] ===
    &array[0][0] /* start of the array */ +
    2 * 7 + 3    /* index transformation 2D to 1D*/

如果是指针：

int **pointer;
pointer[2][3] === *(*(pointer + 2) + 3)

这两个代码片段做了两件完全不同的事情，您不应该将多维数组转换为多星指针，反之亦然。

于 2013-06-22T17:47:07.770 回答