Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::is_trivially_copyable — detetar tipos trivialmente copiáveis

Esta característica de <type_traits> verifica em tempo de compilação se um tipo é trivialmente copiável. Conheça as formas equivalentes ::value e _v e os limites de copiar a representação de um objeto.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#include <type_traits>
std::is_trivially_copyable<T>::value
std::is_trivially_copyable_v<T>

std::is_trivially_copyable<T> de <type_traits> é uma característica de tipo: o seu ::value é uma constante booleana que indica se T é trivialmente copiável. std::is_trivially_copyable_v<T> disponibiliza diretamente o mesmo valor. Utilize-a em static_assert ou if constexpr para verificar requisitos em código genérico.

Estes tipos incluem tipos escalares, classes trivialmente copiáveis, arrays desses tipos e as respetivas variantes com qualificadores cv. Uma classe tem de ter pelo menos uma operação de cópia ou movimentação elegível; cada uma dessas operações elegíveis tem de ser trivial, e o destrutor tem de ser trivial e não eliminado. Isto não verifica propriedades de standard-layout nem se limita a verificar se é possível chamar um construtor de cópia.

A precondição exige que std::remove_all_extents_t<T> seja um tipo completo ou void, possivelmente com qualificadores cv. Por isso, não consulte uma classe antes da sua definição completa. No exemplo, Point satisfaz a característica, ao contrário de NonTrivial, devido ao destrutor fornecido pelo utilizador.

Para dois objetos distintos e existentes do mesmo tipo trivialmente copiável, nenhum dos quais seja um subobjeto potencialmente sobreposto, copiar toda a representação com std::memcpy faz com que o objeto de destino fique com o valor do objeto de origem, desde que os intervalos de bytes de origem e de destino não se sobreponham. Mesmo quando os objetos são distintos, se os intervalos se sobrepuserem, a chamada a std::memcpy tem comportamento indefinido. O exemplo copia Point desta forma. No entanto, true não implica um formato de serialização portátil: a representação pode conter bytes de preenchimento, e os ponteiros não passam a ser cópias dos objetos para os quais apontam. Os requisitos relativos ao tempo de vida dos objetos e ao acesso válido à memória continuam a aplicar-se.

Exemplos

#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

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes