Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::is_trivially_copyable — rilevare i tipi copiabili trivialmente

Questo trait di <type_traits> verifica in fase di compilazione se un tipo è copiabile trivialmente. Scopri le forme equivalenti ::value e _v e i limiti della copia della rappresentazione di un oggetto.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

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

std::is_trivially_copyable<T> di <type_traits> è un trait di tipo: il suo ::value è una costante booleana che indica se T è copiabile trivialmente. std::is_trivially_copyable_v<T> fornisce direttamente lo stesso valore. Usalo in static_assert o if constexpr per verificare i requisiti del codice generico.

Questi tipi includono i tipi scalari, le classi copiabili trivialmente, gli array di tali tipi e le relative varianti con qualificatori cv. Una classe deve avere almeno un’operazione di copia o spostamento ammissibile; ogni operazione ammissibile di questo tipo deve essere triviale e il distruttore deve essere triviale e non eliminato. Questo non verifica le proprietà di standard-layout né si limita a controllare se sia possibile chiamare un costruttore di copia.

La precondizione richiede che std::remove_all_extents_t<T> sia un tipo completo oppure void, eventualmente con qualificatori cv. Non verificare quindi una classe prima della sua definizione completa. Nell’esempio, Point soddisfa il trait, mentre NonTrivial non lo soddisfa a causa del distruttore fornito dall’utente.

Per due oggetti distinti ed esistenti dello stesso tipo copiabile trivialmente, nessuno dei quali sia un sotto-oggetto potenzialmente sovrapposto, copiare l’intera rappresentazione con std::memcpy fa sì che l’oggetto di destinazione assuma il valore dell’oggetto sorgente, a condizione che gli intervalli di byte di origine e di destinazione non si sovrappongano. Anche se gli oggetti sono distinti, la sovrapposizione degli intervalli rende indefinito il comportamento della chiamata a std::memcpy. L’esempio copia Point in questo modo. Tuttavia, true non implica un formato di serializzazione portabile: la rappresentazione può contenere byte di padding e i puntatori non diventano copie degli oggetti a cui puntano. Restano validi i requisiti relativi alla durata degli oggetti e all’accesso valido alla memoria.

Esempi

#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';
}

Risultato

true
3 7

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti