C 如何遍历数组以将它们复制到另一个uint32\t类型的数组中？

我创建了一个C程序，它由一个整数数组结构状态[2]组成。我还需要一个名为store的uint32\u t类型数组。我只想将数组状态[0]的内容复制到存储[0]中，并将状态[1]的内容复制到存储[1]中。我对字符数组使用了这种方法，它似乎很有效。我的代码如下所示：

 #include <stdlib.h>
 #include <stdio.h>

 int main()
 {
     uint32_t *store[2];
     int i;
     int *states[2];
     int states[0] = {1,0,0,1};
     int states[1] = {0,0,0,2};

     for (i = 0; i < 3; i++)
     {
        store[i] = states[i];
        i++;
     }
 }

#包括
#包括
int main（）
{
uint32_t*商店[2]；
int i；
int*国家[2]；
int状态[0]={1,0,0,1}；
int状态[1]={0,0,0,2}；
对于（i=0；i<3；i++）
{
存储[i]=状态[i]；
i++；
}
}

但是代码没有执行，并且说我声明的数组格式无效。我不确定这是否是正确的方法。

---

有人能帮我解决这个问题吗

我重新编写了您的示例—强制调整数组的大小—在这里，它是有效的

EDIT-添加printf调用以显示数组存储的内容

 #include <stdlib.h>
 #include <stdio.h>

 int main()
 {
     int store[3][4];
     int i;
     int states[3][4] = {{1,0,0,1},{0,0,0,2}};

     for(i=0; i<3; i++)
     {
        printf( "store[%d] = ", i );
        for( int inner = 0; inner < 4; inner++ )
        {
           store[i][inner] = states[i][inner];
           printf( "%d ", store[i][inner] ); 
        }
        printf( "\n" );
     }

    return( 0 );   

#包括
#包括
int main（）
{
int store[3][4]；
int i；
int状态[3][4]={{1,0,0,1}，{0,0,2}；
对于（i=0；i我重新编写了您的示例——强制数组的大小——在这里，它是有效的

EDIT-添加printf调用以显示数组存储的内容

 #include <stdlib.h>
 #include <stdio.h>

 int main()
 {
     int store[3][4];
     int i;
     int states[3][4] = {{1,0,0,1},{0,0,0,2}};

     for(i=0; i<3; i++)
     {
        printf( "store[%d] = ", i );
        for( int inner = 0; inner < 4; inner++ )
        {
           store[i][inner] = states[i][inner];
           printf( "%d ", store[i][inner] ); 
        }
        printf( "\n" );
     }

    return( 0 );   

#包括
#包括
int main（）
{
int store[3][4]；
int i；
int状态[3][4]={{1,0,0,1}，{0,0,2}；
对于（i=0；i我重新编写了您的示例——强制数组的大小——在这里，它是有效的

EDIT-添加printf调用以显示数组存储的内容

 #include <stdlib.h>
 #include <stdio.h>

 int main()
 {
     int store[3][4];
     int i;
     int states[3][4] = {{1,0,0,1},{0,0,0,2}};

     for(i=0; i<3; i++)
     {
        printf( "store[%d] = ", i );
        for( int inner = 0; inner < 4; inner++ )
        {
           store[i][inner] = states[i][inner];
           printf( "%d ", store[i][inner] ); 
        }
        printf( "\n" );
     }

    return( 0 );   

#包括
#包括
int main（）
{
int store[3][4]；
int i；
int状态[3][4]={{1,0,0,1}，{0,0,2}；
对于（i=0；i我重新编写了您的示例——强制数组的大小——在这里，它是有效的

EDIT-添加printf调用以显示数组存储的内容

 #include <stdlib.h>
 #include <stdio.h>

 int main()
 {
     int store[3][4];
     int i;
     int states[3][4] = {{1,0,0,1},{0,0,0,2}};

     for(i=0; i<3; i++)
     {
        printf( "store[%d] = ", i );
        for( int inner = 0; inner < 4; inner++ )
        {
           store[i][inner] = states[i][inner];
           printf( "%d ", store[i][inner] ); 
        }
        printf( "\n" );
     }

    return( 0 );   

#包括
#包括
int main（）
{
int store[3][4]；
int i；
int状态[3][4]={{1,0,0,1}，{0,0,2}；
对于（i=0；i代码中有两个问题

首先,

int *states[2];
int states[0] = {1,0,0,1};
int states[1] = {0,0,0,2};

有问题。在访问变量时，不需要提及类型，它仅在定义时才是必需的。因此，使用
int states[0]
或
。[1]
是无效的

那么第二,

states[0] = {1,0,0,1};

state[0]
的类型为
int*
，您试图使用括号括起来的
int
s初始化列表对其进行初始化。这也不正确

您可以修改代码，在访问数组元素时删除类型，并使用复合文字，最后如下图所示

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>   //added for uint32_t 

 int main(void)        //corrected signature
 {
     uint32_t *store[2];
     int i;
     int *states[2];
     states[0] = (int []){1,0,0,1};     //compound literal, C99 and above
     states[1] = (int []){0,0,0,2};

     for (i = 0; i < 2; i++)           //bound corrected
     {
        store[i] = states[i];
                                       //i++; remove this, you're incrementing twice
     }
 }

#包括
#包括
#包括//为uint32\u t添加
int main（void）//更正的签名
{
uint32_t*商店[2]；
int i；
int*国家[2]；
状态[0]=（int[]）{1,0,0,1}；//复合文字，C99及以上
状态[1]=（int[]）{0,0,0,2}；
对于（i=0；i<2；i++）//已更正
{
存储[i]=状态[i]；
//i++；删除此项，您将增加两次
}
}
您的代码中有两个问题

首先,

int *states[2];
int states[0] = {1,0,0,1};
int states[1] = {0,0,0,2};

有问题。在访问变量时，不需要提及类型，它仅在定义时才是必需的。因此，使用
int states[0]
或
。[1]
是无效的

那么第二,

states[0] = {1,0,0,1};

state[0]
的类型为
int*
，您试图使用括号括起来的
int
s初始化列表对其进行初始化。这也不正确

您可以修改代码，在访问数组元素时删除类型，并使用复合文字，最后如下图所示

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>   //added for uint32_t 

 int main(void)        //corrected signature
 {
     uint32_t *store[2];
     int i;
     int *states[2];
     states[0] = (int []){1,0,0,1};     //compound literal, C99 and above
     states[1] = (int []){0,0,0,2};

     for (i = 0; i < 2; i++)           //bound corrected
     {
        store[i] = states[i];
                                       //i++; remove this, you're incrementing twice
     }
 }

#包括
#包括
#包括//为uint32\u t添加
int main（void）//更正的签名
{
uint32_t*商店[2]；
int i；
int*国家[2]；
状态[0]=（int[]）{1,0,0,1}；//复合文字，C99及以上
状态[1]=（int[]）{0,0,0,2}；
对于（i=0；i<2；i++）//已更正
{
存储[i]=状态[i]；
//i++；删除此项，您将增加两次
}
}
您的代码中有两个问题

首先,

int *states[2];
int states[0] = {1,0,0,1};
int states[1] = {0,0,0,2};

有问题。在访问变量时，不需要提及类型，它仅在定义时才是必需的。因此，使用
int states[0]
或
。[1]
是无效的

那么第二,

states[0] = {1,0,0,1};

state[0]
的类型为
int*
，您试图使用括号括起来的
int
s初始化列表对其进行初始化。这也不正确

您可以修改代码，在访问数组元素时删除类型，并使用复合文字，最后如下图所示

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>   //added for uint32_t 

 int main(void)        //corrected signature
 {
     uint32_t *store[2];
     int i;
     int *states[2];
     states[0] = (int []){1,0,0,1};     //compound literal, C99 and above
     states[1] = (int []){0,0,0,2};

     for (i = 0; i < 2; i++)           //bound corrected
     {
        store[i] = states[i];
                                       //i++; remove this, you're incrementing twice
     }
 }

#包括
#包括
#包括//为uint32\u t添加
int main（void）//更正的签名
{
uint32_t*商店[2]；
int i；
int*国家[2]；
状态[0]=（int[]）{1,0,0,1}；//复合文字，C99及以上
状态[1]=（int[]）{0,0,0,2}；
对于（i=0；i<2；i++）//已更正
{
存储[i]=状态[i]；
//i++；删除此项，您将增加两次
}
}
您的代码中有两个问题

首先,

int *states[2];
int states[0] = {1,0,0,1};
int states[1] = {0,0,0,2};

有问题。在访问变量时，不需要提及类型，它仅在定义时才是必需的。因此，使用
int states[0]
或
。[1]
是无效的

那么第二,

states[0] = {1,0,0,1};

state[0]
的类型为
int*
，您试图使用括号括起来的
int
s初始化列表对其进行初始化。这也不正确

您可以修改代码以在访问数组元素时删除类型，并使用复合文字