Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

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.

Fuentes