memcpy of structure having pointers as members in C

Question

I have a structure with some pointers as members and I am trying to do memcpy and I have been suggested that I should not use memcpy in this case as memcpy do a shallow copy (meaning it copies pointers) rather deep copy (meaning copying what pointers point to). But I am not sure why it is not making any difference in the following program: Please have a look at code and output and please explain why it is not a shallow copy in this case? ``` #include #include #include struct student { char *username; char *id; int roll; }; void print_struct(struct student *); void print_struct_addr(struct student *); void changeme(struct student *); int main (void) { struct student *student1; char *name = "ram"; char *id = "200ABCD"; int roll = 34; student1 = (struct student *)malloc(sizeof(struct student)); student1->username = name; student1->id = id; student1->roll = roll; print_struct_addr(student1); print_struct(student1); changeme(student1); print_struct(student1)…

Accepted Answer

This:

```
struct student *student2;
student2->username = "someone";
student2->id = "200EFGH";
student2->roll = 35;
```

Is writing into non-allocated memory, invoking undefined behavior. You need to make sure `student2` is pointing at somewhere valid, before writing.

Either allocate it, or use an on-stack instance since you're just going to copy from it anyway.

Of course, this entire business of initializing `student2` and then overwriting `s` with it is needlessly complicated, you should just modify `s` directly.

Also, this:

```
student1 = (struct student *)malloc(sizeof(struct student));
```

is better written, in C, as:

```
student1 = malloc(sizeof *student1);
```

This removes the pointless (and potentially dangerous) cast, and makes sure the size is the proper one for the type, replacing a dependency checked by the programmer with one handled by the compiler.

Thirdly, it's a bit of a classic "symptom" of the beginning C programmer to not realize that you can assign structures. So, instead of

```
memcpy(s, student2, sizeof *s);
```

You can just write:

```
*s = *student2;
```

And have the compiler to the right thing. This might be a performance win, since the structure can contain a lot of padding which the assignment can be aware of and not copy, but which `memcpy()` cannot ignore.

memcpy of structure having pointers as members in C

Solution

Problem

Related problems