CKTIS / C++
std::is_trivially_copyable — detectar tipos trivialmente copiables
Este rasgo de <type_traits> comprueba en tiempo de compilación si un tipo es trivialmente copiable. Conoce las formas equivalentes ::value y _v, y los límites de copiar la representación de un objeto.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
#include <type_traits>
std::is_trivially_copyable<T>::value
std::is_trivially_copyable_v<T>std::is_trivially_copyable<T> de <type_traits> es un rasgo de tipo: su ::value es una constante booleana que indica si T es trivialmente copiable. std::is_trivially_copyable_v<T> ofrece directamente el mismo valor. Úsalo en static_assert o if constexpr para comprobar requisitos en código genérico.
Entre estos tipos se encuentran los tipos escalares, las clases trivialmente copiables, los arrays de esos tipos y sus variantes con calificadores cv. Una clase debe tener al menos una operación de copia o movimiento admisible; todas esas operaciones admisibles deben ser triviales, y su destructor debe ser trivial y no estar eliminado. Esto no comprueba las propiedades de standard-layout ni se limita a comprobar si se puede llamar a un constructor de copia.
La precondición exige que std::remove_all_extents_t<T> sea un tipo completo o void, posiblemente con calificadores cv. Por tanto, no consultes una clase antes de su definición completa. En el ejemplo, Point cumple el rasgo, mientras que NonTrivial no lo cumple debido a su destructor proporcionado por el usuario.
Para dos objetos distintos y existentes del mismo tipo trivialmente copiable, ninguno de los cuales sea un subobjeto potencialmente solapado, copiar toda la representación mediante std::memcpy hace que el objeto de destino tenga el valor del objeto de origen, siempre que los rangos de bytes de origen y de destino no se solapen. Aunque los objetos sean distintos, si los rangos se solapan, la llamada a std::memcpy tiene un comportamiento indefinido. El ejemplo copia Point de esta forma. Sin embargo, true no implica un formato de serialización portable: la representación puede contener bytes de relleno y los punteros no se convierten en copias de los objetos a los que apuntan. Los requisitos sobre el tiempo de vida de los objetos y el acceso válido a la memoria siguen siendo aplicables.
Ejemplos
#include <cstring>
#include <iostream>
#include <type_traits>
struct Point {
int x;
int y;
};
struct NonTrivial {
~NonTrivial() {}
};
static_assert(std::is_trivially_copyable<Point>::value);
static_assert(!std::is_trivially_copyable_v<NonTrivial>);
int main() {
Point source{3, 7};
Point destination{0, 0};
std::memcpy(&destination, &source, sizeof source);
std::cout << std::boolalpha
<< std::is_trivially_copyable_v<Point> << '\n'
<< destination.x << ' ' << destination.y << '\n';
}
Resultado
true 3 7
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.