Is a class with deleted copy-constructor trivially copyable?

Question

Is this class:

class A {   public:     A() = default;     A(const A&) = delete; }; 

trivially copyable? (At least clang seems to think so (live))

In particular, would

A a,b; std::memcpy(&a, &b, sizeof(A)); 

invoke undefined behavior?

Context: This answer [deleted because proven wrong] plus its comment tree.

Answer 1

Update: The proposed resolution of CWG 1734, currently in "ready" status, would modify [class]/p6 to read:

A trivially copyable class is a class:

• where each copy constructor, move constructor, copy assignment operator, and move assignment operator (12.8 [class.copy], 13.5.3 [over.ass]) is either deleted or trivial,
• that has at least one non-deleted copy constructor, move constructor, copy assignment operator, or move assignment operator, and
• that has a trivial, non-deleted destructor (12.4 [class.dtor]).

This renders classes like

struct B {     B() = default;     B(const B&) = delete;     B& operator=(const B&) = delete; }; 

no longer trivially copyable. (Classes of this sort include synchronization primitives like std::atomic<T> and std::mutex.)

However, the A in the OP has a implicitly declared, non-deleted copy assignment operator that is trivial, so it remains trivially copyable.

The original answer for the pre-CWG1734 situation is preserved below for reference.

---

Yes, somewhat counterintuitively, it is trivially copyable. [class]/p6:

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).

[class.copy]/p12:

A copy/move constructor for class X is trivial if it is not user-provided, its parameter-type-list is equivalent to the parameter-type-list of an implicit declaration, and if

• class X has no virtual functions (10.3) and no virtual base classes (10.1), and
• class X has no non-static data members of volatile-qualified type, and
• the constructor selected to copy/move each direct base class subobject is trivial, and
• for each non-static data member of X that is of class type (or array thereof), the constructor selected to copy/move that member is trivial;

Similarly ([class.copy]/p25):

A copy/move assignment operator for class X is trivial if it is not user-provided, its parameter-type-list is equivalent to the parameter-type-list of an implicit declaration, and if

• class X has no virtual functions (10.3) and no virtual base classes (10.1), and
• class X has no non-static data members of volatile-qualified type, and
• the assignment operator selected to copy/move each direct base class subobject is trivial, and
• for each non-static data member of X that is of class type (or array thereof), the assignment operator selected to copy/move that member is trivial;

[class.dtor]/p5:

A destructor is trivial if it is not user-provided and if:

• the destructor is not virtual,
• all of the direct base classes of its class have trivial destructors, and
• for all of the non-static data members of its class that are of class type (or array thereof), each such class has a trivial destructor.

[dcl.fct.def.default]/p5:

A function is user-provided if it is user-declared and not explicitly defaulted or deleted on its first declaration.

Indeed, this has been a source of problems for the committee itself, because under the current definition atomic<T> (along with mutexes and condition variables) would be trivially copyable. (And obviously, allowing someone to memcpy over an atomic or a mutex without invoking UB would be ... let's just say seriously problematic.) See also N4460.