Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

Atomsko shranjevanje in nalaganje shared_ptr prek prostih funkcij

Preobremenitvi std::atomic_store_explicit in std::atomic_load_explicit za std::shared_ptr omogočata atomsko zamenjavo in branje ročaja z deljenim lastništvom. V C++23 sta zastareli; varujeta ročaj in lastništvo, ne pa poljubnih operacij nad objektom, na katerega kaže ročaj.

Različica: C++23; repository compiler flag, production runtime not attested

Sintaksa

#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.

V C++23 ti funkciji iz <memory> delujeta z običajnim objektom std::shared_ptr<T>, ne z std::atomic<T>. std::atomic_store_explicit(std::shared_ptr<T>*, ...) atomsko zamenja ročaj z vrednostjo desired in vrne void. std::atomic_load_explicit(const std::shared_ptr<T>*, ...) atomsko vrne kopijo ročaja, ki ohrani deljeno lastništvo. Kazalec p mora kazati na objekt, katerega življenjska doba še traja; branje lahko vrne prazen ročaj.

Parameter order določa vrstni red pomnilniških operacij. Za zapis so dovoljeni std::memory_order_relaxed, std::memory_order_release in std::memory_order_seq_cst. Za branje so v C++23 dovoljeni std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire in std::memory_order_seq_cst. Uporaba drugega vrstnega reda povzroči nedefinirano vedenje. Če branje z acquire prebere vrednost, objavljeno z zapisom z release, so učinki predhodne inicializacije vidni; relaxed sam takšne sinhronizacije ne zagotavlja.

Teh operacij ne mešajte z navadnim prirejanjem, klicem reset() ali kopiranjem istega ročaja, če se lahko dostop časovno prekriva z zapisom: to lahko povzroči podatkovno tekmo. Atomičnost ročaja ne varuje sprememb *snapshot; zanje je potrebna ločena sinhronizacija. Prav tako ne predpostavljajte delovanja brez zaklepanja. Objekt slot mora ostati živ ves čas dostopov.

To je zgodovinski vmesnik, zastarel od C++20 in odstranjen v C++26. Na trenutnem naslovu navedenega razdelka je le obvestilo o odstranitvi, ne pa posnetek besedila iz C++23. Nadomestilo je std::atomic<std::shared_ptr<T>> z metodama store() in load(), pri katerem je atomski dostop izražen že v tipu. Ta vnos obravnava C++23; zastavica prevajalnika v repozitoriju ne potrjuje produkcijskega izvajalnega okolja.

Primeri

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

Rezultat

42

Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju po metodi, navedeni v dokazilu o preverjanju prav te različice.

Viri