Comportement de memcpy de C avec le tableau dynamique

Question

Veuillez regarder qu'après memcpy, je change les valeurs dans la matrice de source. Ils sont automatiquement remplacés dans la destination. De plus, quand je change les valeurs des tableaux de destination, ils arrivent au tableau source. Pourquoi cela arrive-t-il? Il est intéressant de noter que même après la suppression du tableau de destination par la commande free, les valeurs restent la source. S'il vous plaît laissez-moi savoir ceci. Merci d'avance.

#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 addition\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"); 
    } 
} 

Answer 1

Le "problème" est ici que vous comprenez mal (apparemment) ce memcpy fait.

Avec

memcpy(M6,  M4, 5 * sizeof(double **)); 

ce que vous faites est essentiellement

M6[0] = M4[0]; 
M6[1] = M4[1]; 
// etc... 

à savoir vous copiez les pointeurs et non ce qu'ils pointent. Lorsque vous appelez free(M6), vous ne libérez que la mémoire que M6 pointe vers. Mais les données pointées par ex. M6[0]etM4[0] existe toujours, et est toujours pointé par M4[0].