4

如果我有一个内部使用 3x3 矩阵的函数，但由于 API 限制，必须将其传递给由九个元素组成的连续数组，有没有办法将数组本质上转换为二维数组？

以下方法不起作用，但希望它传达了我想要做的事情。

我知道像 Eigen 这样的软件包使这变得微不足道，但不幸的是，在这种情况下它不是我的选择。

void transpose_3x3( double x[3][3] ) {
    ...
}

void foo( double x[9], double y[3][3] ) {

    transpose_3x3(y)  // OK    

    double *my_x[3][3] = &x[0];

    transpose_3x3(&my_x);  // How?

}

编辑

感谢 Daniel 向我展示了正确的演员阵容目标，我能够使用 C++ reinterpret_cast 函数来完成这项工作。虽然 union 和 memcpy 解决方案有效，但单一的显式转换似乎是最直接的解决方案，恕我直言。

#include <iostream>

void print_matrix( double x[3][3] ) {

    for(unsigned int i=0; i< 3; i++) {
        for(unsigned int j=0; j<3; j++) {
            std::cout << x[i][j] << "  ";
        }
        std::cout << std::endl;
    }
}

int main() {

    double a[9] = { 1, 2, 3, 4, 5, 6, 7, 8, 9};    
    double (*b)[3] = reinterpret_cast<double (*)[3]>(a);  

    print_matrix(b);
    return 0;
}
4

5 回答 5

7

我想不出一种方法来进行明确的演员表。

但是你可以只是 memcpy 它。调用 memcpy 并不像你想象的那么愚蠢。编译器经常会看到 2 位数据实际上代表相同的东西，并且 memcpy 是固定大小并优化实际副本。

我必须说我从来没有尝试过像你正在做的矩阵这么大的东西，但我不明白为什么它不起作用。

编辑：事实上，我想我会试一试。我写了以下代码：

void transpose_3x3( double (*x)[3][3] ) 
{
    const double t01    = (*x)[0][1];
    const double t02    = (*x)[0][2];
    const double t12    = (*x)[1][2];
    (*x)[0][1] = (*x)[1][0];
    (*x)[0][2] = (*x)[2][0];
    (*x)[1][0] = t01;
    (*x)[1][2] = (*x)[2][1];
    (*x)[2][0] = t02;
    (*x)[2][1] = t12;
}

void foo() 
{
    double x[9] = { 1.0f, 2.0f, 3.0f,
                    4.0f, 5.0f, 6.0f,
                    7.0f, 8.0f, 9.0f };

    double y[3][3];
    memcpy( y, x, sizeof( double ) * 9 );

    transpose_3x3( &y );

    printf( "%f, %f, %f\n", y[0][0], y[0][1], y[0][2] );
    printf( "%f, %f, %f\n", y[1][0], y[1][1], y[1][2] );
    printf( "%f, %f, %f\n", y[2][0], y[2][1], y[2][2] );
}

并使用 VS2010 以发布模式构建它。

生成的程序集如下：

void foo() 
{
00E11000  push        ebp  
00E11001  mov         ebp,esp  
00E11003  and         esp,0FFFFFFC0h  
00E11006  sub         esp,0B8h  
    double x[9] = { 1.0f, 2.0f, 3.0f,
00E1100C  fld1  
00E1100E  push        esi  
00E1100F  fstp        qword ptr [esp+2Ch]  
00E11013  push        edi  
00E11014  fld         qword ptr [__real@4000000000000000 (0E12138h)]  
                    4.0f, 5.0f, 6.0f,
                    7.0f, 8.0f, 9.0f };

    double y[3][3];
    memcpy( y, x, sizeof( double ) * 9 );

    transpose_3x3( &y );

    printf( "%f, %f, %f\n", y[0][0], y[0][1], y[0][2] );
00E1101A  sub         esp,18h  
00E1101D  fstp        qword ptr [esp+50h]  
00E11021  mov         ecx,12h  
00E11026  fld         qword ptr [__real@4008000000000000 (0E12130h)]  
00E1102C  lea         esi,[esp+48h]  
00E11030  fstp        qword ptr [esp+58h]  
00E11034  lea         edi,[esp+90h]  
00E1103B  fld         qword ptr [__real@4010000000000000 (0E12128h)]  
00E11041  fst         qword ptr [esp+60h]  
00E11045  fld         qword ptr [__real@4014000000000000 (0E12120h)]  
00E1104B  fstp        qword ptr [esp+68h]  
00E1104F  fld         qword ptr [__real@4018000000000000 (0E12118h)]  
00E11055  fstp        qword ptr [esp+70h]  
00E11059  fld         qword ptr [__real@401c000000000000 (0E12110h)]  
00E1105F  fst         qword ptr [esp+78h]  
00E11063  fld         qword ptr [__real@4020000000000000 (0E12108h)]  
00E11069  fstp        qword ptr [esp+80h]  
00E11070  fld         qword ptr [__real@4022000000000000 (0E12100h)]  
00E11076  fstp        qword ptr [esp+88h]  
00E1107D  rep movs    dword ptr es:[edi],dword ptr [esi]  
00E1107F  fstp        qword ptr [esp+10h]  
00E11083  fstp        qword ptr [esp+8]  
00E11087  fld         qword ptr [esp+90h]  
00E1108E  fstp        qword ptr [esp]  
00E11091  mov         esi,dword ptr [__imp__printf (0E120A0h)]  
00E11097  push        offset string "%f, %f, %f\n" (0E120F4h)  
00E1109C  call        esi  
    printf( "%f, %f, %f\n", y[1][0], y[1][1], y[1][2] );
00E1109E  add         esp,4  
00E110A1  fld         qword ptr [esp+0C8h]  
00E110A8  fstp        qword ptr [esp+10h]  
00E110AC  fld         qword ptr [esp+0B0h]  
00E110B3  fstp        qword ptr [esp+8]  
00E110B7  fld         qword ptr [__real@4000000000000000 (0E12138h)]  
00E110BD  fstp        qword ptr [esp]  
00E110C0  push        offset string "%f, %f, %f\n" (0E120F4h)  
00E110C5  call        esi  
    printf( "%f, %f, %f\n", y[2][0], y[2][1], y[2][2] );
00E110C7  fld         qword ptr [esp+0D4h]  
00E110CE  add         esp,4  
00E110D1  fstp        qword ptr [esp+10h]  
00E110D5  fld         qword ptr [__real@4018000000000000 (0E12118h)]  
00E110DB  fstp        qword ptr [esp+8]  
00E110DF  fld         qword ptr [__real@4008000000000000 (0E12130h)]  
00E110E5  fstp        qword ptr [esp]  
00E110E8  push        offset string "%f, %f, %f\n" (0E120F4h)  
00E110ED  call        esi  
00E110EF  add         esp,1Ch  
}

您会注意到没有 memcpy。实际上，它所做的只是手动将矩阵从 x 复制到 y 中，然后以转置方式打印它。基本上它很有趣，看看编译器会做些什么来优化事情......

编辑2：当然，在看到稻田的出色回应后，我会想得更远一点，我觉得你可以直接解决这个问题

transpose_3x3( (double (*)[3][3])&x );

没有 memcpy 或 union 可以工作：D

于 2013-01-09T22:41:33.600 回答
6

好吧，这有点脏，但你可以使用 a unionwith cast。有人会因为这个告诉我，但我还是会发布它=）

#include <iostream>

using namespace std;

typedef union {
    double linear[9];
    double square[3][3];
} Matrix;

void transpose_3x3( double x[3][3] )
{
    for( int i = 0; i < 3; i++ ) {
        for( int j = 0; j < 3; j++ ) {
            cout << i << "," << j << ": " << x[i][j] << endl;
        }
    }
}

void foo( double x[9], double y[3][3] )
{
    transpose_3x3( y );
    transpose_3x3( ((Matrix*)x)->square );
}

int main()
{
    double x[9] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    double y[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
    foo( x, y );
    return 0;
}
于 2013-01-09T22:54:35.320 回答
3 
void transpose_3x3( double x[3][3] ) {
    ...
}

请注意，3忽略第一个维度。类型transpose_3x3是真的

void transpose_3x3(double (*)[3])

这告诉我们如何继续，您必须转换x为 a ，一个指向三个sdouble (*)[3]数组的指针。double

void foo(double x[9], double y[3][3]) {
    // Note that the actual types of the parameters are
    // double *x
    // double (*y)[3]

    transpose_3x3(y);
    transpose_3x3((double(*)[3])x);
}

当然，x如果传入的元素短于 9 个元素，则传递演员表会造成严重破坏x，但如果y太短也会出现这种情况。

于 2013-01-10T01:12:15.420 回答
1

您可以定义指向矩阵的指针，如下所示：

int (*matrix)[M][N];

如果你有一个数组 M*N，那么我们基本上可以创建一个指向对象 M*N 的指针：C 支持的本机矩阵不是多维的。

int array[M*N]
int (*matrix)[M][N] = (int (*)[M][N]) array;

如果要访问矩阵中的元素，则可以创建一个函数来简化重复性工作。

int get(int (*matrix)[M][N], int i, int j) { return (*matrix)[i][j]; }
于 2013-08-21T00:15:55.150 回答
0

由于您已经为 C++ 添加了标签，我建议您编写自己的矩阵类，它通过提供辅助函数来访问具有 {x, y} 参数以及 {contiguous x} 参数的数据。

您编写的代码不是您通常在用 C++ 编写的程序中看到的，因为您可以实现相同的逻辑，并且更干净、更安全。

于 2013-01-09T22:42:52.433 回答