5

The C++11 standard guarantees that byte-for-byte copies are always valid for POD types. But what about certain trivial types?

Here's an example:

struct trivial
{
  int x;
  int y;
  trivial(int i) : x(2 * i) { std::cout << "Constructed." << std::endl; }
};

If I were to copy this struct, byte-for-byte, is it guaranteed to copy properly, even though it isn't technically a POD? When is the line drawn as to when it's not okay to byte-copy an object?

Glorfindel
  • 21,988
  • 13
  • 81
  • 109
RétroX
  • 1,996
  • 4
  • 16
  • 24

3 Answers3

9

Yes, it is guaranteed to copy properly.

Quoting the FDIS, §3.9/2:

For any object (other than a base-class subobject) of trivially copyable type T, whether or not the object holds a valid value of type T, the underlying bytes making up the object can be copied into an array of char or unsigned char. If the content of the array of char or unsigned char is copied back into the object, the object shall subsequently hold its original value.

And §3.9/3:

For any trivially copyable type T, if two pointers to T point to distinct T objects obj1 and obj2, where neither obj1 nor obj2 is a base-class subobject, if the underlying bytes making up obj1 are copied into obj2, obj2 shall subsequently hold the same value as obj1.

So the requirements you're asking about are, §3.9/9:

Arithmetic types, enumeration types, pointer types, pointer to member types, std::nullptr_t, and cv-qualified versions of these types are collectively called scalar types. Scalar types, POD classes, arrays of such types and cv-qualified versions of these types are collectively called POD types. Scalar types, trivially copyable class types, arrays of such types, and cv-qualified versions of these types are collectively called trivially copyable types.

And §9/6:

A trivially copyable class is a class that:

  • has no non-trivial copy constructors,
  • has no non-trivial move constructors,
  • has no non-trivial copy assignment operators,
  • has no non-trivial move assignment operators, and
  • has a trivial destructor.
ildjarn
  • 62,044
  • 9
  • 127
  • 211
  • 4
    `trivial::trivial(int)` is not a default or copy constructor. Therefore, it doesn't really affect `trivial`'s copy triviality. – MSN Sep 24 '11 at 01:01
  • 1
    And what MSN says is important because back in C++03, that constructor *does* affect POD-ness. So C++11 allows this, whereas C++03 didn't. – Steve Jessop Oct 03 '12 at 10:44
5

C++11 broke the definition of POD types into more useful categories, specifically 'trivial' and 'standard layout'. Your example is standard layout, and trivally copyable, although the constructor prevents it from being fully trivial. Trivially copyable types are guaranteed to be safely byte-wise copied:

For any object (other than a base-class subobject) of trivially copyable type T, whether or not the object holds a valid value of type T, the underlying bytes (1.7) making up the object can be copied into an array of char or unsigned char.40 If the content of the array of char or unsigned char is copied back into the object, the object shall subsequently hold its original value.

So no, POD status is not required to be safely copied that way, but it is possible to identify the subset of non-POD types that can be.

Dennis Zickefoose
  • 10,791
  • 3
  • 29
  • 38
3

If the standard states it's only defined for POD types (I haven't examined the C++11 standard in detail yet so I don't know if your contention is correct or not (a)) and you do it for a non-POD type, it's not defined behaviour. Period.

It may work, on some implementations, in some environments at certain times of the day, when the planets are aligned. It may work the vast majority of times. That still doesn't make it a good idea if you value portability.

(a) After more investigation, it appears your particular case is okay. Section 3.9/3 of the standard (n3242 draft, but I'd be surprised if it had changed much from this late draft) states:

For any trivially copyable type T, if two pointers to T point to distinct T objects obj1 and obj2 where neither obj1 nor obj2 is a base-class subobject, if the underlying bytes making up obj1 are copied into obj2, obj2 shall subsequently hold the same value as obj1.

Section 9 defines (at a high level) what "trivially copyable" means:

A trivially copyable class is a class that:
- has no non-trivial copy constructors (12.8),
- has no non-trivial move constructors (12.8),
- has no non-trivial copy assignment operators (13.5.3, 12.8),
- has no non-trivial move assignment operators (13.5.3, 12.8), and
- has a trivial destructor (12.4).

with the referenced sections going into more detail on each area, 12.8 for copying and moving class objects and 13.5.3 for assignments.

paxdiablo
  • 854,327
  • 234
  • 1,573
  • 1,953
  • -1 His type is 'trivially copyable', which is the only requirement in C++11 for reconstructing an object from its value representation. – ildjarn Sep 24 '11 at 00:50
  • @ildjarn: hence the "if" at the start. – paxdiablo Sep 24 '11 at 00:51
  • So your answer is "if the thing you say is true then it's illegal, but I don't know whether the thing you say is true"? How is that an answer? – ildjarn Sep 24 '11 at 00:53
  • That's seems to me a _different_ question: "is this particular thing considered a trivially copyable class, hence allowing byte-by-byte copying?" _This_ question stated that it was valid for POD types and this isn't a POD type. – paxdiablo Sep 24 '11 at 00:56
  • The rules were different in C++98 (including TC1). Only POD allowed. – Cheers and hth. - Alf Sep 24 '11 at 00:57
  • 1
    Most questions have a premise and then ask a question based on that premise. Typically, an answer will assume the premise is true. If the question is: "If I'm over 21, can I legally walk into a bar?" the answer will typically assume the person is over 21 and not say something like, "No. You're Jeff Skoggins, I know you, you're only 17." – David Schwartz Sep 24 '11 at 00:58
  • 2
    _This_ question stated that inaccurately. Borrowing the question's inaccuracy does not make the answer more correct. – ildjarn Sep 24 '11 at 00:58
  • 1
    This question stated it was valid for POD types, and then asked if it was *also* valid for any non-POD types. I don't see how there is any confusion here. – Dennis Zickefoose Sep 24 '11 at 01:10
  • @DennisZickefoose : There's no confusion, the answer is just wrong. (Especially for a question tagged `language-lawyer`, where _knowing_ the standard, if not citing it, is expected for a real answer.) – ildjarn Sep 24 '11 at 01:11