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

二维数组使用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

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

#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;
}