You have arrays of double pointers, so simply copying the pointers from one array to the next will not duplicate the data. It will duplicate the pointers that point to the same data, no matter whether you use direct assignment or memcpy. That's called a shallow copy. What you want is a deep copy. Here's a possible implementation:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void printArray(double* array[], size_t rows, size_t cols)
{
for (size_t r=0; r<rows; r++)
{
for (size_t c=0; c<cols; c++)
{
printf("%.2f, ", array[r][c]);
}
printf("\n");
}
}
int main(void)
{
// declare 2 arrays of double pointers
double *positions_particles_source[3];
double *positions_particles_destination[3];
// arbitrarily using 5
size_t number_particles_total = 5;
// allocate space for these pointers to point to
for (size_t i=0; i<3; i++)
{
// allocate the space of 5 doubles for each pointer in each array
positions_particles_source[i] =
calloc(number_particles_total, sizeof(*(positions_particles_source[0])));
// ^^ sizeof(*(positions_particles_source[0])) is the preferred
// method for sizing since you get the type "automatically",
// even if the type changes down the line. Later on I got lazy
// and switched to sizeof(double) because it was less typing
if (positions_particles_source[i] == NULL) exit(-1); // handle error how you want
positions_particles_destination[i] =
calloc(number_particles_total, sizeof(*(positions_particles_destination[0])));
if (positions_particles_destination[i] == NULL) exit(-1);
}
// arbitrarily enter some data in first array
for (size_t i=0; i<3; i++)
{
for (size_t j=0; j<number_particles_total; j++)
{
positions_particles_source[i][j] = (double)i + (double)j + 100.13;
}
}
printf("printing source array\n");
printArray(positions_particles_source, 3, number_particles_total);
// deep copy into destination
for (size_t i=0; i<3; i++)
{
// could also use an inner loop from [0, num_particles)
// and do direct assignment instead of memcpy
memcpy(positions_particles_destination[i],
positions_particles_source[i],
sizeof(double) * number_particles_total);
}
printf("\nprinting dest array\n");
printArray(positions_particles_destination, 3, number_particles_total);
// clear source array
for (size_t i=0; i<3; i++)
{
memset(positions_particles_source[i], 0, sizeof(double) * number_particles_total);
}
// you can see the source array is zeroed out here
printf("\nprinting source array\n");
printArray(positions_particles_source, 3, number_particles_total);
// proves dest array has a deep copy since its data is retained even though
// source has been cleared
printf("\nprinting dest array\n");
printArray(positions_particles_destination, 3, number_particles_total);
// clean up
for (size_t i=0; i<3; i++)
{
free(positions_particles_source[i]);
free(positions_particles_destination[i]);
}
return 0;
}
Output:
printing source array
100.13, 101.13, 102.13, 103.13, 104.13,
101.13, 102.13, 103.13, 104.13, 105.13,
102.13, 103.13, 104.13, 105.13, 106.13,
printing dest array
100.13, 101.13, 102.13, 103.13, 104.13,
101.13, 102.13, 103.13, 104.13, 105.13,
102.13, 103.13, 104.13, 105.13, 106.13,
printing source array
0.00, 0.00, 0.00, 0.00, 0.00,
0.00, 0.00, 0.00, 0.00, 0.00,
0.00, 0.00, 0.00, 0.00, 0.00,
printing dest array
100.13, 101.13, 102.13, 103.13, 104.13,
101.13, 102.13, 103.13, 104.13, 105.13,
102.13, 103.13, 104.13, 105.13, 106.13,
Demo
EDIT:
Based on your comment, I think you have a bit of confusion on the memory layout. I will try to diagram this below, although there is software that draws much prettier pictures than this:
Say you have the code (shortening your variable names ;) )
double* dPtrs[3];
In memory, this is what you have
+-----------------------------+
| double* | double* | double* |
+-----------------------------+
dPtrs[0] | dPtrs[1] | dPtrs[2]
Just on declaration, these 3 double pointers point nowhere, dereferencing them is undefined behavior. You must allocate space for them (using calloc, malloc, etc) before you can use them. The pointers can point to one-to-many doubles each, so say you do
dPtrs[0] = malloc(sizeof(double) * 4);
Assuming malloc doesn't return NULL (you should always check), then dPtrs[0] points to space that can fit 4 doubles somewhere in memory:
+-----------------------------+
| double* | double* | double* |
+-----------------------------+
dPtrs[0] | dPtrs[1] | dPtrs[2]
^^
| +-------------------------------------------------------+
~~~~~> | dPtrs[0][0] | dPtrs[0][1] | dPtrs[0][2] | dPtrs[0][3] |
+-------------------------------------------------------+
You can do something similar for dPtrs[1] and dPtrs[2]. As I hope you can see, dPtrs[i] is a double* type, and dPtrs[i][j] is a double type (always be sure i and j are in bounds). Something like *dPtrs[i][j] is too many dereferences. A double is not an address, and treating it as such will only lead to problems. This is what your compiler is screaming about if I'm understanding you correctly.
