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.