如何在C中将数组拆分为两个数组

Say i have an array in C

假设我在C中有一个数组

int array[6] = {1,2,3,4,5,6}

how could I split this into

我怎么能把它分成两部分

{1,2,3}

and

和

{4,5,6}

Would this be possible using memcpy?

使用memcpy可以实现吗？

Thank You,

谢谢，

nonono

不不不

4 个解决方案

#1

Sure. The straightforward solution is to allocate two new arrays using malloc and then using memcpy to copy the data into the two arrays.

当然。直接的解决方案是使用malloc分配两个新数组，然后使用memcpy将数据复制到两个数组中。

int array[6] = {1,2,3,4,5,6}
int *firstHalf = malloc(3 * sizeof(int));
if (!firstHalf) {
  /* handle error */
}

int *secondHalf = malloc(3 * sizeof(int));
if (!secondHalf) {
  /* handle error */
}

memcpy(firstHalf, array, 3 * sizeof(int));
memcpy(secondHalf, array + 3, 3 * sizeof(int));

However, in case the original array exists long enough, you might not even need to do that. You could just 'split' the array into two new arrays by using pointers into the original array:

但是，如果原始数组存在的时间足够长，您甚至可能不需要这样做。您可以通过使用指向原始数组的指针将数组“拆分”为两个新数组：

int array[6] = {1,2,3,4,5,6}
int *firstHalf = array;
int *secondHalf = array + 3;

#2

// create space for 6 ints and initialize the first 6
int array[6] = {1,2,3,4,5,6};
// reserve space for two lots of 3 contiguous integers
int one[3], two[3]; 
// copy memory of the first 3 ints of array to one
memcpy(one, array, 3 * sizeof(int)); 
// copy 3 ints worth of memory from the 4th item in array onwards
memcpy(two, &array[3], 3 * sizeof(int)); 

#3

You don't have to split them. If you have

您不必拆分它们。如果你有

int *b = array + 3;

you have the second array. When you pass an array to a function, it's turned into a pointer anyway.

你有第二个阵列。将数组传递给函数时，无论如何它都变成了指针。

#4

See the magic how memcpy works, no need to exclusively split the arrays. The changes made in destination array are automatically go to source array and vise versa.

看看memcpy的工作原理，无需专门拆分数组。目标数组中所做的更改将自动转到源数组，反之亦然。

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

double *** double3d(long int dim1,long int dim2,long int dim3)
{
    long int i,j,k;
    double ***array;
    array=(double ***)malloc(dim1*sizeof(double **));
    for(i=0;i<dim1;i++)
    {
     array[i]=(double **)malloc(dim2*sizeof(double *));
     for(j=0;j<dim2;j++)
      array[i][j]=(double *)malloc(dim3*sizeof(double ));
    }
    return array;
}// end double3d

void summ(double ***A,double ***B, double ****C)
{
    int i ,j ,k;
    for(i=0;i<10;i++)
    for(j=0;j<5;j++)
    for(k=0;k<5;k++)
    (*C)[i][j][k]=A[i][j][k]+B[i][j][k];
}

void main()
{
   int i,j,k,nx,ny;
   double ***M1, ***M2, ***M3, ***M4,***M5,***M6;
   nx=5;ny=5;
    M1=double3d(10,nx,ny);
    M2=double3d(10,nx,ny);
    M3=double3d(10,nx,ny);
    M4=double3d(5,nx,ny);
    M5=double3d(5,nx,ny);
    M6=(double ***)malloc(10*sizeof(double **));

    for(i=0;i<10;i++)
    {
        for(j=0;j<nx;j++)
           for(k=0;k<ny;k++)
           {
           M1[i][j][k]=i;
           M2[i][j][k]=1;
           }
    }

// Note random values are in M4 and M5 as they are not initalised
    memcpy(M6,     M4, 5 * sizeof(double **));
    memcpy(M6+5,   M5, 5 * sizeof(double **));

    for(i=0;i<5;i++)
    {
       for(j=0;j<nx;j++)
          for(k=0;k<ny;k++)
          {
               M4[i][j][k]=200;
               M5[i][j][k]=700;
          }
    }

printf(" printing M6 Memcpy before addtion\n");
    for(j=0;j<nx;j++)
    {
       for(k=0;k<ny;k++)
           printf("%f ",M6[4][j][k]);
       printf("\n");
       for(k=0;k<ny;k++)
           printf("%f ",M6[9][j][k]);
       printf("\n");
    }
    // calling for non memcpy array
    summ(M1,M2,&M3); printf(" Non memcpy output last value : %f \n",M3[9][nx-1][ny-1]);
    // calling for memcpy
    summ(M1,M2,&M6); printf(" memcpy output last value : %f \n",M6[9][nx-1][ny-1]);
printf(" printing M6 Memcpy for two sets after addtion\n");
    for(j=0;j<nx;j++)
    {
       for(k=0;k<ny;k++)
           printf("%f ",M6[4][j][k]);
       printf("\n");
    }
    for(j=0;j<nx;j++)
    {
       for(k=0;k<ny;k++)
           printf("%f ",M6[9][j][k]);
       printf("\n");
    }

    free(M6);// cleared M6

printf(" printing M4 Memcpy after deleting M6\n");
    for(j=0;j<nx;j++)
    {
       for(k=0;k<ny;k++)
           printf("%.1f ,%.1f ,%.1f ,%.1f ,%.1f ",M4[0][j][k],M4[1][j][k],M4[2][j][k],M4[3][j][k],M4[4][j][k]);
       printf("\n");
    }

printf(" printing M5 Memcpy after deleting M6\n");
    for(j=0;j<nx;j++)
    {
       for(k=0;k<ny;k++)
           printf("%.1f ,%.1f ,%.1f ,%.1f ,%.1f ",M5[0][j][k],M5[1][j][k],M5[2][j][k],M5[3][j][k],M5[4][j][k]);
       printf("\n");
    }
 }