<atomic> funzioni
atomic_compare_exchange_strong
atomic_compare_exchange_strong_explicit
atomic_compare_exchange_weak
atomic_compare_exchange_weak_explicit
atomic_exchange
atomic_exchange_explicit
atomic_fetch_add
atomic_fetch_add_explicit
atomic_fetch_and
atomic_fetch_and_explicit
atomic_fetch_or
atomic_fetch_or_explicit
atomic_fetch_sub
atomic_fetch_sub_explicit
atomic_fetch_xor
atomic_fetch_xor_explicit
atomic_flag_clear
atomic_flag_clear_explicit
atomic_flag_test_and_set
atomic_flag_test_and_set_explicit
atomic_init
atomic_is_lock_free
atomic_load
atomic_load_explicit
atomic_signal_fence
atomic_store
atomic_store_explicit
atomic_thread_fence
kill_dependency
atomic_compare_exchange_strong
Esegue un'operazione di confronto e scambio atomico.
template <class Ty>
inline bool atomic_compare_exchange_strong(
volatile atomic<Ty>* Atom,
Ty* Exp,
Value) noexcept;
template <class Ty>
inline bool atomic_compare_exchange_strong(
atomic<Ty>* Atom,
Ty* Exp,
Ty Value) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo Ty.
Exp
Puntatore a un valore di tipo Ty.
Value
Valore di tipo Ty.
Valore restituito
true se i valori sono uguali, in caso contrario false.
Osservazioni:
Questo metodo esegue un'operazione di confronto e scambio atomico utilizzando argomenti impliciti memory_order.memory_order_seq_cst . Per ulteriori informazioni, vedere atomic_compare_exchange_strong_explicit.
atomic_compare_exchange_strong_explicit
Esegue un'operazione atomic compare and exchange .
template <class T>
inline bool atomic_compare_exchange_strong_explicit(
volatile atomic<Ty>* Atom,
Ty* Exp,
Ty Value,
memory_order Order1,
memory_order Order2) noexcept;
template <class Ty>
inline bool atomic_compare_exchange_strong_explicit(
atomic<Ty>* Atom,
Ty* Exp,
Ty Value,
memory_order Order1,
memory_order Order2) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo Ty.
Exp
Puntatore a un valore di tipo Ty.
Value
Valore di tipo Ty.
Order1
Primo memory_order argomento.
Order2
Secondo argomento memory_order. Il valore di Order2 non può essere memory_order_release o memory_order_acq_rel, non può essere maggiore del valore di Order1.
Valore restituito
true se i valori sono uguali, in caso contrario false.
Osservazioni:
Un atomic compare and exchange operation oggetto confronta il valore archiviato nell'oggetto a Atom cui punta con il valore a Expcui punta . Se i valori sono uguali, il valore archiviato nell'oggetto a Atom cui punta viene sostituito Value tramite un'operazione di lettura-modifica/scrittura e applicando i vincoli dell'ordine di memoria specificati da Order1. Se i valori non sono uguali, l'operazione sostituisce il valore a Exp cui punta con il valore archiviato nell'oggetto a cui punta Atom e applica i vincoli dell'ordine di memoria specificati da Order2.
atomic_compare_exchange_weak
Esegue un'operazione di confronto e scambio atomico debole.
template <class Ty>
inline bool atomic_compare_exchange_strong(
volatile atomic<Ty>* Atom,
Ty* Exp,
Ty Value) noexcept;
template <class Ty>
inline bool atomic_compare_exchange_strong(
atomic<Ty>* Atom,
Ty* Exp,
Ty Value) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo Ty.
Exp
Puntatore a un valore di tipo Ty.
Value
Valore di tipo Ty.
Valore restituito
true se i valori sono uguali, in caso contrario false.
Osservazioni:
Questo metodo esegue un'operazione di confronto atomico debole e scambio con argomenti implicitimemory_order.memory_order_seq_cst. Per ulteriori informazioni, vedere atomic_compare_exchange_weak_explicit.
atomic_compare_exchange_weak_explicit
Esegue un'operazione di confronto e scambio atomico debole.
template <class Ty>
inline bool atomic_compare_exchange_weak_explicit(
volatile atomic<Ty>* Atom,
Ty* Exp,
Ty Value,
memory_order Order1,
memory_order Order2) noexcept;
template <class Ty>
inline bool atomic_compare_exchange_weak_explicit(
atomic<Ty>* Atom,
Ty* Exp,
Ty Value,
memory_order Order1,
memory_order Order2) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo Ty.
Exp
Puntatore a un valore di tipo Ty.
Value
Valore di tipo Ty.
Order1
Primo memory_order argomento.
Order2
Secondo argomento memory_order. Il valore di Order2 non può essere memory_order_release o memory_order_acq_rel né può essere maggiore del valore di Order1.
Valore restituito
true se i valori sono uguali, in caso contrario false.
Osservazioni:
Sia i sapori forti che deboli di una atomic compare and exchange operation garanzia che non archiviano il nuovo valore se i valori previsti e correnti non sono uguali. Il sapore forte garantisce che archivierà il nuovo valore se i valori previsti e correnti sono uguali. Il sapore debole può talvolta restituire false e non archiviare il nuovo valore anche se i valori correnti e previsti sono uguali. In altre parole, la funzione restituirà false, ma un esame successivo del valore previsto potrebbe rivelare che non è stato modificato e pertanto dovrebbe essere confrontato come uguale.
atomic_exchange
Usa Value per sostituire il valore archiviato di Atom.
template <class T>
inline Ty atomic_exchange(volatile atomic<Ty>* _Atom, Ty Value) noexcept;
template <class Ty>
inline T atomic_exchange(atomic<Ty>* Atom, Ty Value) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo Ty.
Value
Valore di tipo Ty.
Valore restituito
Valore memorizzato di Atom prima dello scambio.
Osservazioni:
La atomic_exchange funzione esegue un'operazione di lettura-modifica/scrittura per scambiare il valore archiviato in Atom con Value, usando .memory_order.memory_order_seq_cst
atomic_exchange_explicit
Sostituisce il valore archiviato di Atom con Value.
template <class Ty>
inline Ty atomic_exchange_explicit(
volatile atomic<Ty>* Atom,
Ty Value,
memory_order Order) noexcept;
template <class Ty>
inline Ty atomic_exchange_explicit(
atomic<Ty>* Atom,
Ty Value,
memory_order Order) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo Ty.
Value
Valore di tipo Ty.
Order
Un oggetto memory_order.
Valore restituito
Valore memorizzato di Atom prima dello scambio.
Osservazioni:
La atomic_exchange_explicit funzione esegue un'operazione di lettura-modifica/scrittura per scambiare il valore archiviato in Atom con Value, all'interno dei vincoli di memoria specificati da Order.
atomic_fetch_add
Aggiunge un valore a un valore esistente archiviato in un oggetto atomic.
template <class T>
T* atomic_fetch_add(volatile atomic<T*>* Atom, ptrdiff_t Value) noexcept;
template <class T>
T* atomic_fetch_add(atomic<T*>* Atom, ptrdiff_t Value) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un puntatore nel tipo T.
Value
Valore di tipo ptrdiff_t.
Valore restituito
Valore del puntatore contenuto dall'oggetto atomic immediatamente prima dell'esecuzione dell'operazione.
Osservazioni:
La atomic_fetch_add funzione esegue un'operazione di lettura-modifica/scrittura per aggiungere Value in modo atomico al valore archiviato in Atom, usando il memory_order.memory_order_seq_cst vincolo .
Quando il tipo atomico è atomic_address, Value è di tipo ptrdiff_t e l'operazione considera il puntatore archiviato come char *.
Questa operazione è anche sottoposta a overload per i tipi integrali:
integral atomic_fetch_add(volatile atomic-integral* Atom, integral Value) noexcept;
integral atomic_fetch_add(atomic-integral* Atom, integral Value) noexcept;
atomic_fetch_add_explicit
Aggiunge un valore a un valore esistente archiviato in un oggetto atomic.
template <class T>
T* atomic_fetch_add_explicit(
volatile atomic<T*>* Atom,
ptrdiff_t Value,
memory_order Order) noexcept;
template <class T>
T* atomic_fetch_add_explicit(
atomic<T*>* Atom,
ptrdiff_t Value,
memory_order Order) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un puntatore nel tipo T.
Value
Valore di tipo ptrdiff_t.
Valore restituito
Valore del puntatore contenuto dall'oggetto atomic immediatamente prima dell'esecuzione dell'operazione.
Osservazioni:
La atomic_fetch_add_explicit funzione esegue un'operazione di lettura-modifica/scrittura per aggiungere Value in modo atomico al valore archiviato in Atom, all'interno dei memory_order vincoli specificati da Order.
Quando il tipo atomico è atomic_address, Value è di tipo ptrdiff_t e l'operazione considera il puntatore archiviato come char *.
Questa operazione è anche sottoposta a overload per i tipi integrali:
integral atomic_fetch_add_explicit(
volatile atomic-integral* Atom,
integral Value,
memory_order Order) noexcept;
integral atomic_fetch_add_explicit(
atomic-integral* Atom,
integral Value,
memory_order Order) noexcept;
atomic_fetch_and
Esegue un & bit per bit in un valore e un valore esistente archiviato in un oggetto atomic.
template <class T>
inline T atomic_fetch_and(volatile atomic<T>* Atom, T Value) noexcept;
template <class T>
inline T atomic_fetch_and(volatile atomic<T>* Atom, T Value) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo T.
Value
Valore di tipo T.
Valore restituito
Valore contenuto dall'oggetto immediatamente prima dell'esecuzione atomic dell'operazione.
Osservazioni:
La atomic_fetch_and funzione esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di Atom con un bit per & bit e Value il valore corrente archiviato in Atomusando il memory_order.memory_order_seq_cst vincolo .
atomic_fetch_and_explicit
Esegue un & bit per bit di un valore e un valore esistente archiviato in un oggetto atomic.
template <class T>
inline T atomic_fetch_and_explicit(
volatile atomic<T>* Atom,
T Value,
memory_order Order) noexcept;
template <class T>
inline T atomic_fetch_and_explicit(
volatile atomic<T>* Atom,
T Value,
memory_order Order) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo T.
Value
Valore di tipo T.
Order
Un oggetto memory_order.
Valore restituito
Valore contenuto dall'oggetto immediatamente prima dell'esecuzione atomic dell'operazione.
Osservazioni:
La atomic_fetch_and_explicit funzione esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di Atom con un bit per & bit e Value il valore corrente archiviato in Atom, all'interno dei vincoli di memoria specificati da Order.
atomic_fetch_or
Esegue un or bit per bit in un valore e un valore esistente archiviato in un oggetto atomic.
template <class T>
inline T atomic_fetch_or (volatile atomic<T>* Atom, T Value) noexcept;
template <class T>
inline T atomic_fetch_or (volatile atomic<T>* Atom, T Value) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo T.
Value
Valore di tipo T.
Valore restituito
Valore contenuto dall'oggetto immediatamente prima dell'esecuzione atomic dell'operazione.
Osservazioni:
La atomic_fetch_or funzione esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di Atom con un bit per or bit e Value il valore corrente archiviato in Atomusando .memory_order.memory_order_seq_cst
atomic_fetch_or_explicit
Esegue un or bit per bit in un valore e un valore esistente archiviato in un oggetto atomic.
template <class T>
inline T atomic_fetch_or_explicit(
volatile atomic<T>* Atom,
T Value,
memory_order Order) noexcept;
template <class T>
inline T atomic_fetch_or_explicit(
volatile atomic<T>* Atom,
T Value,
memory_order Order) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo T.
Value
Valore di tipo T.
Order
Un oggetto memory_order.
Valore restituito
Valore contenuto dall'oggetto immediatamente prima dell'esecuzione atomic dell'operazione.
Osservazioni:
La atomic_fetch_or_explicit funzione esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di Atom con un bit per or bit e Value il valore corrente archiviato in Atom, all'interno dei memory_order vincoli specificati da Order.
atomic_fetch_sub
Sottrae un valore da un valore esistente archiviato in un oggetto atomic.
template <class T>
T* atomic_fetch_sub(
volatile atomic<T*>* Atom,
ptrdiff_t Value) noexcept;
template <class T>
T* atomic_fetch_sub(
atomic<T*>* Atom,
ptrdiff_t Value) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un puntatore nel tipo T.
Value
Valore di tipo ptrdiff_t.
Valore restituito
Valore del puntatore contenuto dall'oggetto atomic immediatamente prima dell'esecuzione dell'operazione.
Osservazioni:
La atomic_fetch_sub funzione esegue un'operazione di lettura-modifica/scrittura per sottrarre Value in modo atomico dal valore archiviato in Atom, usando il memory_order.memory_order_seq_cst vincolo .
Quando il tipo atomico è atomic_address, Value è di tipo ptrdiff_t e l'operazione considera il puntatore archiviato come char *.
Questa operazione è anche sottoposta a overload per i tipi integrali:
integral atomic_fetch_sub(volatile atomic-integral* Atom, integral Value) noexcept;
integral atomic_fetch_sub(atomic-integral* Atom, integral Value) noexcept;
atomic_fetch_sub_explicit
Sottrae un valore da un valore esistente archiviato in un oggetto atomic.
template <class T>
T* atomic_fetch_sub_explicit(
volatile atomic<T*>* Atom,
ptrdiff_t Value,
memory_order Order) noexcept;
template <class T>
T* atomic_fetch_sub_explicit(
atomic<T*>* Atom,
ptrdiff_t Value, memory_order Order) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un puntatore nel tipo T.
Value
Valore di tipo ptrdiff_t.
Valore restituito
Valore del puntatore contenuto dall'oggetto atomic immediatamente prima dell'esecuzione dell'operazione.
Osservazioni:
La atomic_fetch_sub_explicit funzione esegue un'operazione di lettura-modifica/scrittura per sottrarre Value in modo atomico dal valore archiviato in Atom, all'interno dei memory_order vincoli specificati da Order.
Quando il tipo atomico è atomic_address, Value è di tipo ptrdiff_t e l'operazione considera il puntatore archiviato come char *.
Questa operazione è anche sottoposta a overload per i tipi integrali:
integral atomic_fetch_sub_explicit(
volatile atomic-integral* Atom,
integral Value,
memory_order Order) noexcept;
integral atomic_fetch_sub_explicit(
atomic-integral* Atom,
integral Value,
memory_order Order) noexcept;
atomic_fetch_xor
Esegue un exclusive or bit per bit in un valore e un valore esistente archiviato in un oggetto atomic.
template <class T>
inline T atomic_fetch_xor(volatile atomic<T>* Atom, T Value) noexcept;
template <class T>
inline T atomic_fetch_xor(volatile atomic<T>* Atom, T Value) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo T.
Value
Valore di tipo T.
Valore restituito
Valore contenuto dall'oggetto immediatamente prima dell'esecuzione atomic dell'operazione.
Osservazioni:
La atomic_fetch_xor funzione esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di Atom con un bit per exclusive or bit e Value il valore corrente archiviato in Atomusando .memory_order.memory_order_seq_cst
atomic_fetch_xor_explicit
Esegue un bit per exclusive or bit su un valore e un valore esistente archiviato in un atomic oggetto .
template <class T>
inline T atomic_fetch_xor_explicit(
volatile atomic<T>* Atom,
T Value,
memory_order Order) noexcept;
template <class T>
inline T atomic_fetch_xor_explicit(
volatile atomic<T>* Atom,
T Value,
memory_order Order) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo T.
Value
Valore di tipo T.
Order
Un oggetto memory_order.
Valore restituito
Valore contenuto dall'oggetto immediatamente prima dell'esecuzione atomic dell'operazione.
Osservazioni:
La atomic_fetch_xor_explicit funzione esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di Atom con un bit per exclusive or bit e Value il valore corrente archiviato in Atom, all'interno dei memory_order vincoli specificati da Order.
atomic_flag_clear
Imposta il bool flag in un atomic_flag oggetto su false, all'interno di memory_order.memory_order_seq_cst.
inline void atomic_flag_clear(volatile atomic_flag* Flag) noexcept;
inline void atomic_flag_clear(atomic_flag* Flag) noexcept;
Parametri
Flag
Puntatore a un oggetto atomic_flag.
atomic_flag_clear_explicit
Imposta il bool flag in un atomic_flag oggetto su false, all'interno dei vincoli specificati memory_order .
inline void atomic_flag_clear_explicit(volatile atomic_flag* Flag, memory_order Order) noexcept;
inline void atomic_flag_clear_explicit(atomic_flag* Flag, memory_order Order) noexcept;
Parametri
Flag
Puntatore a un oggetto atomic_flag.
Order
Un oggetto memory_order.
atomic_flag_test_and_set
Imposta il bool flag in un atomic_flag oggetto su true, all'interno dei vincoli di memory_order.memory_order_seq_cst.
inline bool atomic_flag_test_and_set(volatile atomic_flag* Flag,) noexcept;
inline bool atomic_flag_test_and_set(atomic_flag* Flag,) noexcept;
Parametri
Flag
Puntatore a un oggetto atomic_flag.
Valore restituito
Il valore iniziale di Flag.
atomic_flag_test_and_set_explicit
Imposta il bool flag in un atomic_flag oggetto su true, all'interno dei vincoli specificati memory_order .
inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* Flag, memory_order Order) noexcept;
inline bool atomic_flag_test_and_set_explicit(atomic_flag* Flag, memory_order Order) noexcept;
Parametri
Flag
Puntatore a un oggetto atomic_flag.
Order
Un oggetto memory_order.
Valore restituito
Il valore iniziale di Flag.
atomic_init
Imposta il valore archiviato in un oggetto atomic.
template <class Ty>
inline void atomic_init(volatile atomic<Ty>* Atom, Ty Value) noexcept;
template <class Ty>
inline void atomic_init(atomic<Ty>* Atom, Ty Value) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo Ty.
Value
Valore di tipo Ty.
Osservazioni:
atomic_init non è un'operazione atomica. Non è thread-safe.
atomic_is_lock_free
Specifica se le operazioni atomiche in un oggetto atomic sono senza blocco.
template <class T>
inline bool atomic_is_lock_free(const volatile atomic<T>* Atom) noexcept;
template <class T>
inline bool atomic_is_lock_free(const atomic<T>* Atom) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che archivia un valore di tipo T.
Valore restituito
true se le operazioni atomiche in Atom sono senza blocco; in caso contrario, false.
Osservazioni:
Un tipo atomico è senza blocco se nessuna operazione atomica su tale tipo usa i blocchi. Se questa funzione restituisce true, il tipo è sicuro da usare nei gestori di segnale.
atomic_load
Recupera il valore archiviato in un oggetto atomic.
template <class Ty>
inline Ty atomic_load(const volatile atomic<Ty>* Atom) noexcept;
template <class Ty>
inline Ty atomic_load(const atomic<Ty>* Atom) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che contiene un valore di tipo Ty.
Valore restituito
Valore recuperato archiviato in Atom.
Osservazioni:
atomic_loadusa in modo implicito .memory_order.memory_order_seq_cst
atomic_load_explicit
Recupera il valore archiviato in un atomic oggetto , all'interno di un oggetto specificato memory_order.
template <class Ty>
inline Ty atomic_load_explicit(const volatile atomic<Ty>* Atom, memory_order Order) noexcept;
template <class Ty>
inline Ty atomic_load_explicit(const atomic<Ty>* Atom, memory_order Order) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che contiene un valore di tipo Ty.
Order
Un oggetto memory_order. Non usare memory_order_release o memory_order_acq_rel.
Valore restituito
Valore recuperato archiviato in Atom.
atomic_signal_fence
Funge da recinto , una primitiva di sincronizzazione della memoria che impone l'ordinamento tra le operazioni di caricamento/archiviazione, tra altre barriere in un thread chiamante con gestori di segnale eseguiti nello stesso thread.
inline void atomic_signal_fence(memory_order Order) noexcept;
Parametri
Order
Un vincolo di ordinamento della memoria che determina il tipo di limite.
Osservazioni:
L'argomento Order determina il tipo di limite.
| valore | Descrizione |
|---|---|
memory_order_relaxed |
Il limite non ha effetto. |
memory_order_consume |
Il limite è un limite di acquisizione. |
memory_order_acquire |
Il limite è un limite di acquisizione. |
memory_order_release |
Il limite è un limite di rilascio. |
memory_order_acq_rel |
Il limite è sia un limite di acquisizione che un limite di rilascio. |
memory_order_seq_cst |
Il limite è sia un limite di acquisizione che un limite di rilascio ed è sequenzialmente coerente. |
atomic_store
Archivia in modo atomico un valore in un atomic oggetto .
template <class Ty>
inline Ty atomic_store_explicit(const volatile atomic<Ty>* Atom, Ty Value) noexcept;
template <class Ty>
inline Ty atomic_store_explicit(const atomic<Ty>* Atom, T Value) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che contiene un valore di tipo Ty.
Value
Valore di tipo Ty.
Osservazioni:
atomic_store archivia Value nell'oggetto a Atomcui punta , all'interno del memory_order.memory_order_seq_cst vincolo .
atomic_store_explicit
Archivia in modo atomico un valore in un atomic oggetto .
template <class Ty>
inline Ty atomic_store_explicit(
const volatile atomic<Ty>* Atom,
Ty Value,
memory_order Order) noexcept;
template <class Ty>
inline Ty atomic_store_explicit(
const atomic<Ty>* Atom,
T Value,
memory_order Order) noexcept;
Parametri
Atom
Puntatore a un oggetto atomic che contiene un valore di tipo Ty.
Value
Valore di tipo Ty.
Order
Un oggetto memory_order. Non usare memory_order_consume, memory_order_acquire o memory_order_acq_rel.
Osservazioni:
atomic_store archivia Value nell'oggetto a cui punta Atom nei limiti di memory_order specificato da Order.
atomic_thread_fence
Funge da limite , una primitiva di sincronizzazione della memoria che impone l'ordinamento tra le operazioni di caricamento/archiviazione, senza un'operazione atomica associata.
inline void atomic_thread_fence(memory_order Order) noexcept;
Parametri
Order
Un vincolo di ordinamento della memoria che determina il tipo di limite.
Osservazioni:
L'argomento Order determina il tipo di limite.
| valore | Descrizione |
|---|---|
memory_order_relaxed |
Il limite non ha effetto. |
memory_order_consume |
Il limite è un limite di acquisizione. |
memory_order_acquire |
Il limite è un limite di acquisizione. |
memory_order_release |
Il limite è un limite di rilascio. |
memory_order_acq_rel |
Il limite è sia un limite di acquisizione che un limite di rilascio. |
memory_order_seq_cst |
Il limite è sia un limite di acquisizione che un limite di rilascio ed è sequenzialmente coerente. |
kill_dependency
Rimuove una dipendenza.
template <class Ty>
Ty kill_dependency(Ty Arg) noexcept;
Parametri
Arg
Valore di tipo Ty.
Valore restituito
Viene restituito il valore Arg. La valutazione di Arg non mantiene una dipendenza per la chiamata di funzione. Interrompendo una possibile catena di dipendenze, la funzione potrebbe consentire al compilatore di generare codice più efficiente.