Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::is_nothrow_copy_constructible — costruzione per copia senza eccezioni

Questo tratto di <type_traits> verifica in fase di compilazione se la costruzione di T da const T& è valida e non può lanciare eccezioni. std::is_nothrow_copy_constructible<T>::value e std::is_nothrow_copy_constructible_v<T> espongono lo stesso risultato bool.

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

Sintassi

#include <type_traits>

std::is_nothrow_copy_constructible<T>::value
std::is_nothrow_copy_constructible_v<T>

std::is_nothrow_copy_constructible<T> è un template di classe di <type_traits> il cui membro ::value è una costante di tipo bool. std::is_nothrow_copy_constructible_v<T> è un template di variabile che espone lo stesso valore. Il risultato può essere usato in static_assert e if constexpr.

Per un tipo T per il quale è possibile formare un riferimento, il risultato equivale a std::is_nothrow_constructible_v<T, const T&>: l’inizializzazione diretta deve essere valida e non deve poter lanciare eccezioni. Per gli altri tipi, il risultato è false. Il test non esegue il costruttore; anche un costruttore vuoto dichiarato noexcept(false) produce false.

Il tratto verifica la costruzione, non l’assegnazione né la trivialità della copia. Se la risoluzione degli overload per la costruzione da const T& seleziona un costruttore eliminato o non accessibile, il risultato è false. Ad esempio, per una classe T con un costruttore T(T&) eliminato e un costruttore pubblico T(const T&) dichiarato noexcept, la risoluzione degli overload seleziona il costruttore pubblico. Questo da solo non garantisce un risultato pari a true: se il distruttore è eliminato o non accessibile, la definizione ipotetica di variabile usata nel test non è valida e il risultato è false. Per i tipi riferimento, verifica il binding del riferimento anziché la copia dell’oggetto referenziato; per esempio, std::is_nothrow_copy_constructible_v<int&> è true.

T deve essere un tipo completo, eventualmente void qualificato cv, oppure un array di dimensione sconosciuta. Non usare questo tratto per esaminare una classe dichiarata in avanti prima della sua definizione. Non aggiungere specializzazioni personalizzate di questi template: ciò rende indefinito il comportamento del programma.

Esempi

#include <iostream>
#include <type_traits>

struct Safe {
    Safe(const Safe&) noexcept {}
};

struct Risky {
    Risky(const Risky&) noexcept(false) {}
};

struct Blocked {
    Blocked(const Blocked&) = delete;
};

static_assert(std::is_nothrow_copy_constructible<Safe>::value);
static_assert(!std::is_nothrow_copy_constructible_v<Risky>);
static_assert(!std::is_nothrow_copy_constructible_v<Blocked>);

int main() {
    std::cout << std::boolalpha
              << std::is_nothrow_copy_constructible<Safe>::value << '\n'
              << std::is_nothrow_copy_constructible_v<Risky> << '\n'
              << std::is_nothrow_copy_constructible_v<Blocked> << '\n';
}

Risultato

true
false
false

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