Q:

What is the difference between is_trivially_copyable and is_trivially_copy_constructible?

When would these give a different answer, and when would this difference be useful, if at all?

A:

The former tests for the trivially copyable property, which in few words means that the type is memcpy-safe.

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).
A trivial class is a class that has a trivial default constructor (12.1) and is trivially copyable.
[ Note: In particular, a trivially copyable or trivial class does not have virtual functions
  or virtual base classes.—end note ]

The latter tests for the presence of a trivial copy constructor, which incidentally is a requirement for the trivially copyable property. It basically implies that the copy constructor for the type performs a bitwise copy.

A copy/move constructor for class X is trivial if it is not user-provided and if
— class X has no virtual functions (10.3) and no virtual base classes (10.1), 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;
otherwise the copy/move constructor is non-trivial.

It is easy to fabricate a type that provides different results for these traits:
struct foo {
    foo(foo const&) = default; // this is a trivial copy constructor
    ~foo(); // this is a non-trivial destructor
};

