C 将指针的结构信息转换为数组

我对for循环有一个问题，它应该将指针的结构信息放在数组中。此结构用于复数。问题是数字m[n].re/.im-它们不是korrekt

typedef struct
{
  float re, im;
} Complex;

#define N 2
#define M 2

int main()
{
Complex* p;
Complex matrix[N][M]; //already filled
Complex m[N*M];
int n;

n = 0;
p = NULL;

for(p = &matrix[0][0]; p<= &matrix[0][0]+N*M-1; p++)
    {
        m[n] = *p;
        n = n+1;
    }
}

typedef结构
{
浮动re，im；
}复杂的；
#定义n2
#定义m2
int main（）
{
复合物*p；
复矩阵[N][M]；//已填充
复m[N*m]；
int n；
n=0；
p=零；
例如，对于（p=&matrix[0][0]；p您可以使用header
中声明的标准C函数
memcpy

memcpy( m, matrix, N * M * sizeof( Complex ) ); 

如果您想使用一个使用指针的循环，那么它可以按照下面的方式查看示例

for ( Complex *q = ( Complex * )matrix, *p = m; q != ( Complex * )matrix + N * M; p++, q++ )
{
    *p = *q;
}

例如，您可以使用header
中声明的标准C函数
memcpy

memcpy( m, matrix, N * M * sizeof( Complex ) ); 

如果您想使用一个使用指针的循环，那么它可以按照下面的方式查看示例

for ( Complex *q = ( Complex * )matrix, *p = m; q != ( Complex * )matrix + N * M; p++, q++ )
{
    *p = *q;
}

我认为指针
p
包含一个
结构复合体的地址

for(p = &matrix[0][0]; p<= &matrix[0][0]+N*M-1; p = p + sizeof(int))
    {
        m[n] = *p;
        n = n+1;
    }
}

Complex matrix[N][M];
Complex array[N*M];

Complex *p = array;
for ( int n = 0; n < N; n++ )
    for ( int m = 0; m < M; m++ )
        *p++ = matrix[n][m];

for（p=&matrix[0][0]；p我认为指针
p
包含一个
struct Complex
的地址。不确定，但像这样尝试一次

for(p = &matrix[0][0]; p<= &matrix[0][0]+N*M-1; p = p + sizeof(int))
    {
        m[n] = *p;
        n = n+1;
    }
}

Complex matrix[N][M];
Complex array[N*M];

Complex *p = array;
for ( int n = 0; n < N; n++ )
    for ( int m = 0; m < M; m++ )
        *p++ = matrix[n][m];

for（p=&matrix[0][0]；p复制的最快方法是使用
memcpy
，但是如果要使用循环，代码应该如下所示

for(p = &matrix[0][0]; p<= &matrix[0][0]+N*M-1; p = p + sizeof(int))
    {
        m[n] = *p;
        n = n+1;
    }
}

Complex matrix[N][M];
Complex array[N*M];

Complex *p = array;
for ( int n = 0; n < N; n++ )
    for ( int m = 0; m < M; m++ )
        *p++ = matrix[n][m];

复矩阵[N][M]；
复阵[N*M]；
复数*p=数组；
对于（int n=0；n


作为对注释的响应，只要给出一个指向矩阵的指针，并且知道维度，就可以创建一个类似于二维数组的指针

void someFunction( Complex *matrix, int sizeN, int sizeM )
{
    Complex (*p)[sizeM] = (void *)matrix;

    for ( int n = 0; n < sizeN; n++ )
        for ( int m = 0; m < sizeM; m++ )
            printf( "%f %f\n", p[n][m].re, p[n][m].im );
}

void someFunction（复数*矩阵，int-sizeN，int-sizeM）
{
复数（*p）[sizeM]=（void*）矩阵；
对于（int n=0；n
复制的最快方法是使用
memcpy
，但是如果要使用循环，代码应该如下所示

for(p = &matrix[0][0]; p<= &matrix[0][0]+N*M-1; p = p + sizeof(int))
    {
        m[n] = *p;
        n = n+1;
    }
}

Complex matrix[N][M];
Complex array[N*M];

Complex *p = array;
for ( int n = 0; n < N; n++ )
    for ( int m = 0; m < M; m++ )
        *p++ = matrix[n][m];

复矩阵[N][M]；
复阵[N*M]；
复数*p=数组；
对于（int n=0；n


作为对注释的响应，只要给出一个指向矩阵的指针，并且知道维度，就可以创建一个类似于二维数组的指针

void someFunction( Complex *matrix, int sizeN, int sizeM )
{
    Complex (*p)[sizeM] = (void *)matrix;

    for ( int n = 0; n < sizeN; n++ )
        for ( int m = 0; m < sizeM; m++ )
            printf( "%f %f\n", p[n][m].re, p[n][m].im );
}

void someFunction（复数*矩阵，int-sizeN，int-sizeM）
{
复数（*p）[sizeM]=（void*）矩阵；
对于（int n=0；n
我修改了您的程序，以初始化矩阵数组，并在复制后使用for循环将矩阵和数组m的值打印到标准输出：

#include <stdio.h>

typedef struct
{
  float re, im;
} Complex;

#define N 2
#define M 2

int main()
{
    Complex* p;
    Complex matrix[N][M]; //already filled
    Complex m[N*M];
    int idx, jdx, val = 1;
    for (idx = 0; idx < N; idx++) {
            for (jdx = 0; jdx < M; jdx++) {
                    matrix[idx][jdx].re = val;
                    matrix[idx][jdx].im = val;
                    ++val;
            }
    }
    int n;

    n = 0;
    p = NULL;

    for (p = &matrix[0][0]; p < &matrix[0][0] + N*M; p++)
    {
            printf("matrix[%d] = %f + %fi\n", n, p->re, p->im);
            m[n] = *p;
            n = n+1;
    }

    int midx = 0;
    for (midx = 0; midx < N*M; midx++) {
            printf("m[%d] = %f + %fi\n", midx, m[midx].re, m[midx].im);
    }
    return 0;

#包括
类型定义结构
{
浮动re，im；
}复杂的；
#定义n2
#定义m2
int main（）
{
复合物*p；
复矩阵[N][M]；//已填充
复m[N*m]；
int-idx，jdx，val=1；
对于（idx=0；idxre，p->im）；
m[n]=*p；
n=n+1；
}
int midx=0；
对于（midx=0；midx

}

我不确定发生了什么，但对我来说，看起来你没有初始化数组。记住，memcpy是你的朋友。希望这段代码能有所帮助。
我修改了你的程序来初始化矩阵数组，并在复制后使用for循环将矩阵和数组m的值打印到标准输出：

#include <stdio.h>

typedef struct
{
  float re, im;
} Complex;

#define N 2
#define M 2

int main()
{
    Complex* p;
    Complex matrix[N][M]; //already filled
    Complex m[N*M];
    int idx, jdx, val = 1;
    for (idx = 0; idx < N; idx++) {
            for (jdx = 0; jdx < M; jdx++) {
                    matrix[idx][jdx].re = val;
                    matrix[idx][jdx].im = val;
                    ++val;
            }
    }
    int n;

    n = 0;
    p = NULL;

    for (p = &matrix[0][0]; p < &matrix[0][0] + N*M; p++)
    {
            printf("matrix[%d] = %f + %fi\n", n, p->re, p->im);
            m[n] = *p;
            n = n+1;
    }

    int midx = 0;
    for (midx = 0; midx < N*M; midx++) {
            printf("m[%d] = %f + %fi\n", midx, m[midx].re, m[midx].im);
    }
    return 0;

#包括
类型定义结构
{
浮动re，im；
}复杂的；
#定义n2
#定义m2
int main（）
{
复合物*p；
复矩阵[N][M]；//已填充
复m[N*m]；
int-idx，jdx，val=1；
对于（idx=0；idxre，p->im）；
m[n]=*p；
n=n+1；
}
int midx=0；
对于（midx=0；midx

}

我不确定发生了什么，但对我来说，只是看起来你没有初始化数组。记住，memcpy是你的朋友。希望这段代码能有所帮助。
1）使用标准类型！C已经有了
\u Complex
（尽管它是可选的-请检查编译器）。2）类型是有原因的。为什么不在两个维度中正确索引2D数组呢？3）不要使用单字母宏名称。错误之处在于，例如，
行
？4）使用相同的字母，但大小写不同，已经是不好的样式。将它们用于不相关的项目更糟糕。为什么注释“已填充”？
复杂矩阵[N][M]
未初始化。基本上，我认为您的代码没有问题。它将按预期工作。（2D数组的特殊情况，包括那些不必要的情况除外）1）使用标准类型！C已经有了
\u复杂的
（尽管它是可选的-检查编译器）.2）使用类型是有原因的。为什么不在两个维度中正确索引2D数组？3）不要使用单字母宏名称。错误之处在于，例如，
行
？4）使用同一个字母但大小写不同已经是不好的样式。将它们用于不相关的项目更糟糕。为什么注释“已填充”？
复杂矩阵[N][M]；
未初始化。基本上，我认为