std::is_trivially_copyable

Defined in header `<type_traits>`
template< class T > struct is_trivially_copyable;		(since C++11)

std::is_trivially_copyable is a UnaryTypeTrait.

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

If std::remove_all_extents_t<T> is an incomplete type and not (possibly cv-qualified) void, the behavior is undefined.

If the program adds specializations for std::is_trivially_copyable or std::is_trivially_copyable_v, the behavior is undefined.

Template parameters

T

-

a type to check

Helper variable template

template< class T > constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;		(since C++17)

Inherited from std::integral_constant

Member constants

value

[static]

true if T is a trivially copyable type, false otherwise
(public static member constant)

Member functions

operator bool	converts the object to bool, returns value (public member function)
operator() (C++14)	returns value (public member function)

Member types

Type	Definition
`value_type`	bool
`type`	std::integral_constant<bool, value>

Notes

Objects of trivially-copyable types that are not potentially-overlapping subobjects are the only C++ objects that may be safely copied with std::memcpy or serialized to/from binary files with std::ofstream::write() / std::ifstream::read().

Example

Run this code

#include <type_traits>
 
struct A { int m; };
static_assert(std::is_trivially_copyable_v<A> == true);
 
struct B { B(B const&) {} };
static_assert(std::is_trivially_copyable_v<B> == false);
 
struct C { virtual void foo(); };
static_assert(std::is_trivially_copyable_v<C> == false);
 
struct D
{
    int m;
 
    D(D const&) = default; // -> trivially copyable
    D(int x) : m(x + 1) {}
};
static_assert(std::is_trivially_copyable_v<D> == true);
 
int main() {}

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 2015	C++11	`T` could be an array of incomplete class type with unknown bound	the behavior is undefined in this case

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries