Which type trait would indicate that type is memcpy assignable? (tuple, pair)

Question

I would like to know what type introspection I can do to detect types that assignable by simply raw memory copy?

For example, as far I understand, built-in types tuples

Answer 1

To try and answer your question: std::memcpy() does not have any direct requirements but it does have these stipulations:

• Copies count bytes from the object pointed to by src to the object pointed to by dest. Both objects are reinterpreted as arrays of unsigned char.

• If the objects overlap, the behavior is undefined.
• If either dest or src is a null pointer, the behavior is undefined, even if count is zero.
• If the objects are not TriviallyCopyable, the behavior of memcpy is not specified and may be undefined.

---

Now to have the qualifications that an object is Trivially Copyable the following conditions or requirements must be met:

• Every copy constructor is trivial or deleted

• Every move constructor is trivial or deleted
• Every copy assignment operator is trivial or deleted
• Every move assignment operator is trivial or deleted
• at least one copy constructor, move constructor, copy assignment operator, or move assignment operator is non-deleted
• Trivial non-deleted destructor

This implies that the class has no virtual functions or virtual base classes.

Scalar types and arrays of TriviallyCopyable objects are TriviallyCopyable as well, as well as the const-qualified (but not volatile-qualified) versions of such types.

---

Which leads us to std::is_trivially_copyable

If T is a TriviallyCopyable type, provides the member constant value equal true. For any other type, value is false.

The only trivially copyable types are scalar types, trivially copyable classes, and arrays of such types/classes (possibly const-qualified, but not volatile-qualified).

The behavior is undefined if std::remove_all_extents_t is an incomplete type and not (possibly cv-qualified) void.

with this nice feature since c++17:

Helper variable template

template< class T >

inline constexpr bool is_trivially_copyable_v = is_trivially_copyable::value; 

---

And you would like to try and use a type_trait to use std::tuple<> with std::memcpy().

But we need to ask ourselves if std::tuple is Trivially Copyable and why?

We can see the answer to that here: Stack-Q/A: std::tuple Trivially Copyable? and according to that answer; it is not because the standard does not require the copy/move assignment operators to be trivial.

---

So the answer that I would think that is valid would be this: No std::tuple is not Trivially Copyable but std::memcpy() doesn't require it to be but only states that if it isn't; it is UB. So can you use std::tuple with std::memcpy? I think so, but is it safe? That can vary and can produce UB.

So what can we do from here? Take a risk? Maybe. I found something else that is related but have not found anything out about it regarding if it is Trivially Copyable. It is not a type_trait, but it is something that might be able to be used in conjunction with std::tuple & std::memcpy and that is std::tuple_element. You might be able to use this to do the memcpy, but I'm not fully sure about it. I have searched to find out more about std::tuple_element to see if it is Trivially Copyable but haven't found much so all I can do is a test to see what Visual Studio 2017 says:

template
struct type_list {
    template
    using type = typename std::tuple_element>::type;
};

int main() {
    std::cout << std::boolalpha;
    std::cout << std::is_trivially_copyable>::value << '\n';
    std::cout << std::is_trivially_copyable>::value << '\n';

    _getch(); // used to stop visual studio debugger from closing.
    return 0;
}

Output:

true
false

So it appears if we wrap std::tuple_element in a struct it is Trivially Copyable. Now the question is how do you integrate this with your std::tuple data sets to use them with std::memcpy() to be type safe. Not sure if we can since std::tuple_element will return the types of the elements within a tuple.

If we even tried to wrap a tuple in a struct as such:

template
struct wrapper {
    std::tuple t;
};

And we can check it by:

{
    std::cout << std::is_trivially_copyable< wrapper >::value << std::endl;
}

It is still false. However we have seen were std::tuple was already used in the first struct and the struct returned true. This may be of some help to you, to ensure you can safely use std::memcpy, but I can not guarantee it. It is just that the compiler seems to agree with it. So this might be the closest thing to a type_trait that might work.

---

NOTE: - All the references about memcpy, Trivially Copyable concepts, is_trivially_copyable, std::tuple & std::tuple_element were taken from cppreference and their relevant pages.