Re: Regarding assignment to struct

On 04/05/2025 16:27, Scott Lurndal wrote:

James Kuyper <jameskuyper@alumni.caltech.edu> writes:

On 5/3/25 20:37, Keith Thompson wrote:

Lawrence D'Oliveiro <ldo@nz.invalid> writes:

On Sat, 3 May 2025 01:14:46 -0700, Andrey Tarasevich wrote:

Virtually every C project relies on assignment of structures.
Passing-returning structs by value might be more rare (although
perfectly valid and often appropriate too), but assignment...
assignment is used by everyone everywhere without even giving it a
second thought.

>
There is a caveat, to do with alignment padding: will this always have a
defined value?

>
I don't believe so.  In a quick look, I don't see anything in
the standard that explicitly addresses this, but I believe that a
conforming implementation could implement structure assignment by
copying the individual members, leaving any padding in the target
undefined.

>
"When a value is stored in an object of structure or union type,
including in a member object, the bytes of the object representation
that correspond to any padding bytes take unspecified values.56)"
(6.2.6.1p6).
>
That refers to footnote 56, which says "Thus, for example, structure
assignment need not copy any padding bits."

 Are there any C implementations in common use that don't just
use memcpy or an optimized version thereof?
 

Sometimes small structs never make it to memory, or are handled by the compiler as though they were individual variables (as long as that is within "as-if" usage, of course).  Copying a struct might merely mean the compiler keeps track of the logical copy without actually copying any memory.  (You could argue that the compiler is still treating it like memcpy, as memcpy calls don't always copy something.)
I think it would be unusual to see a significant difference between a struct assignment copy and a memcpy on a compiler that optimises memcpy well.
But on a compiler that does not handle memcpy well, then a struct assignment could be inlined while a memcpy could mean an external library call with significant overhead.