Copying a struct to a larger struct?

[hermes_917]

I want to use memcpy to copy the contents of one struct to another
which is a superset of the original struct (the second struct has extra
members at the end). I wrote a small program to test this, and it
seems to work fine, but are there any cases where doing something like
this could cause any problems?

Here's the small program I wrote to test this:

#include <stdio.h>
int main()
{
struct simplestruct
{
int i;
char str[8];
};

struct extendedstruct
{
int i;
char str[8];
int j;
};

struct simplestruct foostruct;
struct extendedstruct barstruct;

/* Populate the members of the simplestruct instance */
foostruct.i=7;
strcpy(foostruc t.str, "Test");

/* Copy the contents of the simplestruct instance to the
extendedstruct instance */
memcpy(&barstru ct, &foostruct, sizeof(foostruc t));

/* Populate remaining member of the extendedstruct instance */
barstruct.j=13;

/* Print values of members of the extendedstruct instance */
printf("i\t%d\n str\t%s\nj\t%d\ n", barstruct.i, barstruct.str,
barstruct.j);
}

Thanks in advance for any advice.
--
Karl Garrison
he********@yaho o.com

[tedu]

he********@yaho o.com wrote:

struct simplestruct
{
int i;
char str[8];
};

struct extendedstruct
{
int i;
char str[8];
int j;
};

A lower maintainence, less error prone way to do this is
struct simplestruct { ... };
struct extendedstruct { struct simplestruct s; ... };

[Michael Mair]

he********@yaho o.com wrote:

I want to use memcpy to copy the contents of one struct to another
which is a superset of the original struct (the second struct has extra
members at the end). I wrote a small program to test this, and it
seems to work fine, but are there any cases where doing something like
this could cause any problems?

Here's the small program I wrote to test this:

#include <stdio.h>
int main()
{
struct simplestruct
{
int i;
char str[8];
};

struct extendedstruct
{
int i;
char str[8];
int j;
};

struct simplestruct foostruct;
struct extendedstruct barstruct;

/* Populate the members of the simplestruct instance */
foostruct.i=7;
strcpy(foostruc t.str, "Test");

/* Copy the contents of the simplestruct instance to the
extendedstruct instance */
memcpy(&barstru ct, &foostruct, sizeof(foostruc t));

/* Populate remaining member of the extendedstruct instance */
barstruct.j=13;

/* Print values of members of the extendedstruct instance */
printf("i\t%d\n str\t%s\nj\t%d\ n", barstruct.i, barstruct.str,
barstruct.j);
}

Thanks in advance for any advice.

It is possible that sizeof foostruct == sizeof barstruct;
take another example:

struct simplestruct
{
int i;
char str[7];
};

struct extendedstruct
{
int i;
char str[7];
unsigned char j;
};

On typical implementations with 8bit char and 32bit or 16bit int and
minimal padding, it is now probable that sizeof foostruct == sizeof
barstruct, so your padding in simplestruct overwrites your useful
information in extendedstruct.
So, either you memcpy() (offsetof(struc t simplestruct, str) + sizeof
foostruct.str) bytes (the offsetof macro comes from <stddef.h>) or
you follow the hint given in another reply, namely
struct extendedstruct
{
struct simplestruct mySimple;
unsigned char j;
}
Then, you do not even need memcpy():
barstruct.mySim ple = foostruct;
suffices.
(In addition, you can abuse the address of barstruct as a
struct simplestruct*, if necessary -- but I have not said that ;-))
Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.

[Barry Schwarz]

On 27 Jul 2005 12:32:08 -0700, "he********@yah oo.com"
<kg*******@pobo x.com> wrote:

I want to use memcpy to copy the contents of one struct to another
which is a superset of the original struct (the second struct has extra
members at the end). I wrote a small program to test this, and it
seems to work fine, but are there any cases where doing something like
this could cause any problems?

There is no guarantee that the padding in the common part of the two
structs is the same. It is also possible for the shorter struct to
have padding at the end but in the longer struct there could be an
actual member at the same offset.
<<Remove the del for email>>

[Grumble]

tedu wrote:

A lower maintainence [...]

to maintain, yes, but maintenance ;-)

[CBFalconer]

"he********@yah oo.com" wrote:

I want to use memcpy to copy the contents of one struct to another
which is a superset of the original struct (the second struct has
extra members at the end). I wrote a small program to test this,
and it seems to work fine, but are there any cases where doing
something like this could cause any problems?

Why do snaky things in the first place? Just write down what you
want:

struct smaller {
....
} smallguy;

struct bigger {
struct smaller small;
....
} bigguy;

....

bigguy.small = smallguy;

and I find it hard to imagine what could go wrong.

--
"If you want to post a followup via groups.google.c om, don't use
the broken "Reply" link at the bottom of the article. Click on
"show options" at the top of the article, then click on the
"Reply" at the bottom of the article headers." - Keith Thompson

[Randy Howard]

CBFalconer wrote
(in article <42************ ***@yahoo.com>) :

Why do snaky things in the first place?

you are trying to implement an adder?

<duck>
--
Randy Howard (2reply remove FOOBAR)

[Alexei A. Frounze]

"Barry Schwarz" <sc******@deloz .net> wrote in message
news:g7******** *************** *********@4ax.c om...

On 27 Jul 2005 12:32:08 -0700, "he********@yah oo.com" .... There is no guarantee that the padding in the common part of the two
structs is the same.

If my memory serves me, the standard gurantees that. But, I'd prefer to turn
that common part into a type used inside both structs. memcpy() will be able
to do bad things silently...

Alex

[Netocrat]

On Fri, 29 Jul 2005 00:56:03 +0400, Alexei A. Frounze wrote:

"Barry Schwarz" <sc******@deloz .net> wrote in message
news:g7******** *************** *********@4ax.c om...

On 27 Jul 2005 12:32:08 -0700, "he********@yah oo.com" ...

There is no guarantee that the padding in the common part of the two
structs is the same.

If my memory serves me, the standard gurantees that.

Perhaps you aren't using error correction on your memory. :)

Barry is right, the standard doesn't guarantee it. The alignment of
members within a struct is "implementa tion-defined" (I can't imagine why
in practice a compiler would not pad them identically, but it isn't
prohibited from padding differently).

The only guarantees about member positions in structs are that no hole
will occur at the beginning and that members will occupy increasing
storage addresses.

Padding also may be added at the end to ensure correct alignment for
arrays of the struct (but this is again at the implementation' s discretion
- i.e. not of predictable / guaranteed / repeatable size).
But, I'd prefer to turn
that common part into a type used inside both structs. memcpy() will be able
to do bad things silently...

memcpy() may do bad things if the common part is not padded identically,
as well as if the smaller struct has padding at the end in space at which
the larger struct has a member.

You're right that your preferred solution is safe though.

[Keith Thompson]

Netocrat <ne******@dodo. com.au> writes:

On Fri, 29 Jul 2005 00:56:03 +0400, Alexei A. Frounze wrote:

"Barry Schwarz" <sc******@deloz .net> wrote in message
news:g7******** *************** *********@4ax.c om...

On 27 Jul 2005 12:32:08 -0700, "he********@yah oo.com" ...

There is no guarantee that the padding in the common part of the two
structs is the same.

If my memory serves me, the standard gurantees that.

Perhaps you aren't using error correction on your memory. :)

Barry is right, the standard doesn't guarantee it. The alignment of
members within a struct is "implementa tion-defined" (I can't imagine why
in practice a compiler would not pad them identically, but it isn't
prohibited from padding differently).

The only guarantees about member positions in structs are that no hole
will occur at the beginning and that members will occupy increasing
storage addresses.

But there is an additional guarantee. C99 6.5.2.3p5 says:

One special guarantee is made in order to simplify the use of
unions: if a union contains several structures that share a common
initial sequence (see below), and if the union object currently
contains one of these structures, it is permitted to inspect the
common initial part of any of them anywhere that a declaration of
the complete type of the union is visible. Two structures share a
common initial sequence if corresponding members have compatible
types (and, for bit-fields, the same widths) for a sequence of one
or more initial members.

There's no explicit guarantee *unless* the two structures are members
of the same union, but it's hard to imagine an implementation other
than the DS9K meeting this requirement for union members without
meeting it for all structures with common initial sequences.
Padding also may be added at the end to ensure correct alignment for
arrays of the struct (but this is again at the implementation' s discretion
- i.e. not of predictable / guaranteed / repeatable size).

But, I'd prefer to turn
that common part into a type used inside both structs. memcpy() will be able
to do bad things silently...

memcpy() may do bad things if the common part is not padded identically,
as well as if the smaller struct has padding at the end in space at which
the larger struct has a member.

Yes, that can be a problem even given the additional guarantee above.
For example, given:

struct foo {
int x;
char y;
}

struct foobar {
int x;
char y;
char z;
}

it's effectively guaranteed that the x and y members will have the
same size and offset in both structures, but the z member of struct
foobar could very well occupy some of the padding of struct foo.
You're right that your preferred solution is safe though.

Agreed.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.