Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Caricamenti e memorizzazioni atomici di shared_ptr tramite funzioni libere

Le overload di std::atomic_store_explicit e std::atomic_load_explicit per std::shared_ptr sostituiscono e recuperano atomicamente un handle condiviso. In C++23 sono deprecate: proteggono l’handle e la proprietà condivisa, non operazioni arbitrarie sull’oggetto puntato.

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

Sintassi

#include <memory>
#include <atomic>

template<class T>
void atomic_store_explicit(std::shared_ptr<T>* p,
                           std::shared_ptr<T> desired,
                           std::memory_order order);

template<class T>
std::shared_ptr<T> atomic_load_explicit(const std::shared_ptr<T>* p,
                                        std::memory_order order);
// Both function templates belong to namespace std.

In C++23, queste funzioni di <memory> operano su un normale oggetto std::shared_ptr<T>, non su un std::atomic<T>. std::atomic_store_explicit(std::shared_ptr<T>*, ...) sostituisce atomicamente l’handle con desired e restituisce void. std::atomic_load_explicit(const std::shared_ptr<T>*, ...) restituisce atomicamente una copia dell’handle che mantiene la proprietà condivisa. Il puntatore p deve indicare un oggetto vivo; un caricamento può restituire un handle vuoto.

Il parametro order seleziona l’ordinamento della memoria. Per le memorizzazioni sono consentiti std::memory_order_relaxed, std::memory_order_release e std::memory_order_seq_cst. In C++23, per i caricamenti sono consentiti std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire e std::memory_order_seq_cst. Altri ordinamenti causano comportamento indefinito. Un caricamento acquire che legge il valore pubblicato da una memorizzazione release rende visibile l’inizializzazione precedente; relaxed da solo non fornisce tale sincronizzazione.

Non combinare queste operazioni con un’assegnazione ordinaria, reset() o la copia dello stesso handle quando l’accesso può sovrapporsi a una scrittura: si rischia una data race. L’atomicità dell’handle non protegge le modifiche a *snapshot; queste richiedono una sincronizzazione separata. Non presumere neppure che l’operazione sia priva di lock. Mantieni vivo l’oggetto slot per tutta la durata degli accessi.

Questa è un’interfaccia storica, deprecata da C++20 e rimossa in C++26. L’indirizzo attuale della sezione fornita segnala soltanto la rimozione; non è un’istantanea di C++23. Il sostituto è std::atomic<std::shared_ptr<T>> con i metodi store() e load(), che esprimono l’accesso atomico nel tipo. Questa voce riguarda C++23; il flag del compilatore del repository non attesta un runtime di produzione.

Esempi

#include <atomic>
#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<const int> slot;
    std::shared_ptr<const int> value = std::make_shared<const int>(42);

    std::atomic_store_explicit(&slot, value, std::memory_order_release);
    auto snapshot = std::atomic_load_explicit(&slot, std::memory_order_acquire);

    std::cout << *snapshot << '\n';
}

Risultato

42

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