Thread: memcpy use?

Originally Posted by jerrykellyjr

I am using memcpy to copy the contents from buffer1 to buffer2. I use memcpy to copy buffer3 to buffer4. My question is this: Is there a way to append buffer4 to buffer2 so that I don't overwrite any of the data in buffer2?

As long as buffer2 has enough room to support its existing contents and buffer4's contents then sure, why not? It is just a matter of knowing how much stuff is already in buffer2 and then copying buffer4's contents to the end of that data in buffer2.

Maybe something like:

Code:

char big_buffer[2000];
char buffer2[1000];
char buffer4[500];

...

memcpy( big_buffer, buffer2, sizeof(buffer2) );
memcpy( big_buffer+sizeof(buffer2), buffer4, sizeof(buffer4) );

That should do what you want.

Now I get an access violation. Here is what I am trying to do:

Code:

struct car_data_struct {
int blue;
int green;
int red;
float weight;
float miles_driven;
}

struct cars_struct {
int number_of_cars;
int car_id;
char car_name[10];
car_data_struct cardata[50];
}

struct cars_struct2 {
int number_of_cars;
int car_id;
char car_name[10];
car_data_struct cardata[50];
}

struct big_car_struct {
int number_of_cars;
int car_id;
char car_name[10];
car_data_struct cardata[100];
}

// in another application I do this:
car_struct car_buf;
car_struct2 car_buf2;
big_car_struct big_car_buf;

memcpy(big_car_buf, car_buf, sizeof(car_struct));
memcpy(big_car_buf + sizeof(car_struct), car_buf2, sizeof(car_struct2));

OK I revised my code to show instances.
What I really want to do in the second memcpy is only copy the cardata from car_buf2 to big_car_buf. Can this be done?

One big problem, you don't have any instances of the structs to copy to/from. You need to be operating on instances of the struct. Also, since car_struct and car_struct2 are the same, you don't really need two different structs, two instances of a single struct should be fine:

Code:

struct color_struct {
int blue;
int green;
int red;
float weight;
float miles_driven;
};

struct cars_struct {
int number_of_cars;
int car_id;
char car_name[10];
color_struct colors[50];
};


struct big_car_struct {
int number_of_cars;
int car_id;
char car_name[10];
color_struct colors[100];
};

car_struct car1, car2;  // Two instances of car_struct
big_car_struct big_car;  // Single instance of big_car_struct

You probably don't want to use memcpy in this instance for copying the two car_structs into the one big_car_struct. Think of what you are trying to do by merging them. What is happening when you combine car1 with car2? What is supposed to happen? Do you wish to to add the two number_of_cars variables from car1 and car2 and have the result in the respective variable in big_car? What happens to the car_id field and the car_name value?

The only somewhat suitable place for you to really use memcpy that I can see is to copy the two 50 element colors array from car1 and car2 into big_car's large 100 element colors array. But many people might just use a loop to do that copying.

As someone in one of your other threads mentioned (I think it was Prelude?), that sort of thing doesn't work. You'll have to manually copy each variable in each struct somehow (a direct memory copy will NOT work).

**EDIT**
Beaten by HK. Listen to him, his explanation is more thorough.

OK I'm thoroughly confused!
I want to copy all of car_buf to big_big_car_buf. Then I need to copy only the car_data from car_buf2 to big_car_buf so that it's appended onto the end of the car_buf data. Can this be accomplished? Thanks!

Here's my revised code:

Code:

struct car_data_struct {
int Car_length;
int Car_Width;
int Car_Height;
float weight;
float miles_driven;
}

struct cars_struct {
int number_of_cars;
int car_id;
char car_name[10];
car_data_struct cardata[50];
}

struct cars_struct2 {
int number_of_cars;
car_data_struct cardata[50];
}

struct big_car_struct {
int number_of_cars;
int car_id;
char car_name[10];
car_data_struct cardata[100];
}

// in another application I do this:
car_struct car_buf;
car_struct2 car_buf2;
big_car_struct big_car_buf;

memcpy(big_car_buf, car_buf, sizeof(car_struct));

memcpy(big_car_buf + sizeof(car_struct), car_buf2, sizeof(car_struct2));

Code:

big_car_buf.number_of_cars = car_buf.number_of_cars;
big_car_buf.car_id = car_buf.car_id;

strcpy(big_car_buf.car_name, car_buf.car_name);

int i;  //<-- Edited here
for(i = 0; i < 50; ++i)
   big_car_buf.car_data_struct[i] = car_buf.car_data_struct[i];

for(; i < 100; ++i)
   big_car_buf.cardata[i] = car_buf2.cardata[i - 50];

It isn't rocket science, really. memcpy() is useful in many places, and this is not one of them (for the reasons mentioned in the other thread - structs are not compatible, even if you line them up perfectly). Structs may look the same, but internally you usually have little if any idea how they're really put together - so you should generally NEVER attempt a 'copy' in this manner.

**NOTICE: Edited to correct a small error.

I am using memcpy to copy the contents from buffer1 to buffer2. I use memcpy to copy buffer3 to buffer4.

I just saw this. You're using the word 'buffer' wrong - what you're dealing with are structures, not buffers. A buffer is usually just an array of bytes, i.e.

Code:

char myBuffer[500];  //A buffer of size 500.

If you're dealing with this sort of thing, then by all means use memcpy - you're just copying an ordered sequence of bytes from one place to another. But with structures, you have no guarantee what size it'll end up with and you have no guarantee of how the data is arranged inside - so unless you're copying from one structure to another structure of exactly the same type, i.e.:

Code:

struct A
{
   int data1;
   int data2;
};

A struct1;
A struct2;

Then you can probably get away with memcpy(), but a simple struct1 = struct2; would suffice anyway so you wouldn't use memcpy() here anyway.

You will find that memcpy()'s uses are usually limited to more advanced topics.

It can be done using the function memcpy; but it's less efficient, uglier, less safe, and in general completely pointless. I have already posted a fully functional code example of how you can properly do exactly what you have just stated.

If you want to know how to do it with memcpy:

Code:

memcpy(&(big_car_buf.number_of_cars), &(car_buf.number_of_cars), sizeof(int));
etc. etc. for each member.

You cannot directly memcpy one struct into another unless they are of the same type, as has been stated about 4 times already. IT DOESN'T MATTER IF THEY HAVE THE SAME VARIABLE TYPES DECLARED IN THE SAME ORDER WITH THE SAME NAMES!!! They are INCOMPATIBLE if they are declared as different structs. If a direct memory copy works at all, it is only by chance and is not by any means guaranteed.

>>I need to know first, can this be done using memcpy?
No, not safely. structs of differing types should not be copied over each other.

>>please provide an example
hunter2 already has. Copy the individual elements, the use a loop to copy the cardata array elements.

[beat!]

In the example hunter gave for the second loop:

Code:

for(; i < 100; ++i)
   big_car_buf.cardata[i] = car_buf2.cardata[i - 50];

will this copy the data to elements 50 through 99 in big_car_buf.cardata[i] ?