二维数组使用memcpy赋值，使用malloc动态申请内存,以及结构体数组的memcpy

女爷i 2024-04-18 11:52 1阅读 0赞

### 二维数组使用memcpy赋值： ###

//void *memcpy(void *dest, const void *src, size_t n);从源src所指的内存地址的起始位置开始拷贝n个
    //字节到目标dest所指的内存地址的起始位置中。调用该函数需要引用string.h头文件.
    int a[M][N], b[M][N];
    memcpy(b, a, sizeof(a));
    
    /结构体中二维数组的memcpy//
    memcpy(cl_ctx->wq[0], ctx->wq[0], sizeof(cl_ctx->wq[0]));//指针在64位系统占8个字节，ctx->wq[1]是指针，因此sizeof(ctx->wq[1])=8，故不可用
    memcpy(cl_ctx->wq[1], ctx->wq[1], sizeof(cl_ctx->wq[1]));
    //或者
    memcpy(&cl_ctx->wq[0][0], &ctx->wq[0][0], sizeof(cl_ctx->wq));
    memcpy(cl_ctx->wq, ctx->wq, sizeof(cl_ctx->wq));
    //均可以.
    //但是如果两个结构体中第一个是wq[2][64],另一个是*wq[2],则只能使用上面的两个对每个维度单独赋值,因为*wq[2]的第二维可能不是64.

///结构体数组的memcpy///
    typedef struct _CL_CORE{
    	ENC_SBAC     s_curr_before_split[MAX_CU_DEPTH][MAX_CU_DEPTH];
    	ENC_SBAC     s_curr_best[MAX_CU_DEPTH][MAX_CU_DEPTH];
    	ENC_SBAC     s_next_best[MAX_CU_DEPTH][MAX_CU_DEPTH];
    	ENC_CU_DATA  cu_data_best[MAX_CU_DEPTH][MAX_CU_DEPTH];
    	ENC_CU_DATA  cu_data_temp[MAX_CU_DEPTH][MAX_CU_DEPTH];
    }CL_CORE;
    
    memcpy(&cl_core->s_curr_before_split[0][0], &core->s_curr_before_split[0][0], sizeof(cl_core->s_curr_before_split));
    memcpy(cl_core->s_curr_before_split, core->s_curr_before_split, sizeof(cl_core->s_curr_before_split));

**例一：**

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    void printarr2d(int (*a)[3],int row,int col);
    int main()
    {
        int i,j;
        int a[2][3] = {
       {1,2,3},{4,5,6}};
        int b[4][3] = {
       {0,0,0},{0,0,0}};
         memcpy(b[2],a,sizeof(int)*2*3);//b[2]代表以b[2]为起始地址开始赋值
         printarr2d(b,4,3);
         return 0;
    }
    /***********************************************
    打印显示数组
    ************************************************/
    void printarr2d(int (*a)[3],int row,int col)
    {
     int i,j;
     for(i=0; i<row; i++)
        {
            for(j=0; j<col; j++)
            {
                printf("%d", a[i][j]);
            }
             printf("\n");
        }
    }

## ##

**例二：**

#include"string.h" 
    #include"stdio.h"
    int main(void)
    { 
      int i,j;
      int a[2][3]={
       {1,2,3},{4,5,6}};  
      int b[2][3];
      memcpy(&b[0][0],&a[0][0],24);
      printf("%d",b[1][0]);
    }

**例三：**

#include <stdio.h>
    void print(int *data,size_t m,size_t n); //二维数组显示子函数
    
    int main(void)
    {
        int src[][3]={
       {1,2,3},{4,5,6},{7,8,9},{1,2,3},{4,5,6},{7,8,9}};  
        int des[6][3]={0,0};//要小心，行数固定
        printf("%d",sizeof(src));
        print(src,6,3);
        memcpy(des,src,sizeof(src));
        print(des,6,3);
    
        return 1;
    }
    //二维子函数显示功能
    void print(int data[][3], size_t m,size_t n)
    {
    
        int i,j;
        
        printf("\n");
        for(i=0;i<m;i++)
        {    for(j=0;j<n;j++)
            {
                printf("%d ",data[i][j]);
            }
        printf("\n");
        }
    }

### **二维数组使用malloc动态申请内存：** ###

[https://blog.csdn.net/fengxinlinux/article/details/51541003][https_blog.csdn.net_fengxinlinux_article_details_51541003]

**方法一：利用二级指针申请一个二维数组。**

#include<stdio.h>  
    #include<stdlib.h>  
      
      
    int main()  
    {  
        int **a;  //用二级指针动态申请二维数组  
        int i,j;  
        int m,n;  
        printf("请输入行数\n");  
        scanf("%d",&m);  
        printf("请输入列数\n");  
        scanf("%d",&n);  
        a=(int**)malloc(sizeof(int*)*m);  
        for(i=0;i<m;i++)  
        a[i]=(int*)malloc(sizeof(int)*n);  
        for(i=0;i<m;i++)  
        {
            for(j=0;j<n;j++)  
            {
                printf("%p\n",&a[i][j]);     //输出每个元素地址，每行的列与列之间的地址时连续的，行与行之间的地址不连续
            }
        }
        for(i=0;i<m;i++)  
        free(a[i]);
     
        free(a);  
        return 0;  
    }

**方法二：用数组指针形式申请一个二维数组。**

#include<stdio.h>  
    #include<stdlib.h>  
      
      
    int main()  
    {  
        int i,j;  
        //申请一个3行2列的整型数组  
        int (*a)[2]=(int(*)[2])malloc(sizeof(int)*3*2);  
        for(i=0;i<3;i++)  
        {
            for(j=0;j<2;j++)  
            {  
                printf("%p\n",&a[i][j]);  //输出数组每个元素地址，每个元素的地址是连续的
            }
        }
     
     
        free(a);
        return 0;  
    }

**方法三：用一个单独的一维数组来模拟二维数组。**

#include <stdio.h>
    #include <stdlib.h>
     
     
    int main()
    {
        int nrows,ncolumns;
        int *Array;
        int i,j;
        printf("please input nrows&ncolumns:\n");
        scanf("%d%d",&nrows,&ncolumns);
        Array=(int *)malloc(nrows*ncolumns*sizeof(int));   //申请内存空间
        for(i=0;i<nrows;i++)
        {
            for(j=0;j<ncolumns;j++)
            {
                Array[i*ncolumns+j]=1;
                printf("%d ",Array[i*ncolumns+j]);   //用Array[i*ncolumns+j] 访问第i,j个成员
            }
            printf("\n");
        }
        free(Array);
        return 0;
    }

[https_blog.csdn.net_fengxinlinux_article_details_51541003]: https://blog.csdn.net/fengxinlinux/article/details/51541003