If I have a structure defined like:
struct image{
unsigned int width, height;
unsigned char *data;
};
And 2 variables of this type:
struct image image1;
struct image image2;
I want to transfer the data from image1 to the data of image2(presuming image1 has some data written, and image2 has data allocated with malloc or calloc). How can it be done? Thanks a lot.
Assuming it is undesirable that two instances of struct image are pointing to the same data then memcpy() cannot be used to copy the structs. To copy:
data buffer based on source datawidth membersmemcpy() data members.For example:
struct image* deep_copy_image(const struct image* img)
{
struct image* result = malloc(sizeof(*result));
if (result)
{
/* Assuming 'width' means "number of elements" in 'data'. */
result->width = img->width;
result->data = malloc(img->width);
if (result->data)
{
memcpy(result->data, img->data, result->width);
}
else
{
free(result);
result = NULL;
}
}
return result;
}
height member. result->height, typo?did you try memcpy(&image1,&image2,sizeof(image));
edit: Alocate data for image2.data after that you have to strcpy(image2.data,image1.data) if data is null terminated, but if its not, then use memcpy with the size of data.
Regards, Luka
struct image so that sizeof will throw an error.struct image image1;
struct image image2;
...
image2.width = image1.width;
image2.height = image1.height;
/* assuming data size is width*height bytes, and image2.data has enough space allocated: */
memcpy(image2.data, image1.data, width*height);
If all you want is duplicating the struct (i. e. creating a "shallow" copy):
image2 = image1;
if you also want to copy the data pointed to by image1.data ("deep copy"), then you need to do that manually:
memcpy(image2.data, image1.data, image1.width * image1.height);
(assuming there are image1.width * image1.height bytes in the data, and there's enough space malloc()ated in image2.data for storing that.)
image2.data will point to image1.data which is not correct. Each member should be copied separately.
data member of image2 would be leaked.It's simple in C. Simply do the following (assuming image2 is uninitialized):
image2 = image1; //there's no deep copy, pointed to memory isn't copied
You can assign one structure variable to other given they are of the same type. No need to copy piece-meal. This is a useful feature of C.
This has been discussed before:
data member of image2. If you assume that image2 is effectively uninitialised before this assignment, it'll be important to say this explicitly.