CKTIS / C++
Atomair laden en opslaan van shared_ptr via vrije functies
De std::shared_ptr-overloads van std::atomic_store_explicit en std::atomic_load_explicit vervangen en lezen atomair een gedeelde handle. Ze zijn verouderd in C++23; ze beschermen de handle en het gedeelde eigendom, niet willekeurige bewerkingen op het aangewezen object.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
#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 werken deze functies uit <memory> op een gewoon object std::shared_ptr<T>, niet op een std::atomic<T>. std::atomic_store_explicit(std::shared_ptr<T>*, ...) vervangt de handle atomair door desired en retourneert void. std::atomic_load_explicit(const std::shared_ptr<T>*, ...) retourneert atomair een kopie van de handle die het gedeelde eigendom behoudt. De aanwijzer p moet naar een levend object verwijzen; een leesbewerking kan een lege handle retourneren.
De parameter order kiest de geheugenvolgorde. Voor opslag zijn std::memory_order_relaxed, std::memory_order_release en std::memory_order_seq_cst toegestaan. Voor laden zijn in C++23 std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire en std::memory_order_seq_cst toegestaan. Andere volgorden veroorzaken ongedefinieerd gedrag. Een acquire-load die de waarde leest die door een release-store is gepubliceerd, maakt eerdere initialisatie zichtbaar; relaxed alleen zorgt niet voor die synchronisatie.
Combineer deze bewerkingen niet met gewone toewijzing, reset() of het kopiëren van dezelfde handle wanneer toegang kan overlappen met een schrijfoperatie: dat kan een data-race veroorzaken. De atomiciteit van de handle beschermt wijzigingen aan *snapshot niet; daarvoor is afzonderlijke synchronisatie nodig. Ga er ook niet van uit dat de bewerking lock-free is. Houd het object slot gedurende alle toegang in leven.
Dit is een historische interface, verouderd sinds C++20 en verwijderd in C++26. Het huidige adres van de aangeleverde sectie meldt alleen de verwijdering; het is geen C++23-momentopname. De vervanging is std::atomic<std::shared_ptr<T>> met de methoden store() en load(), die atomaire toegang in het type uitdrukken. Dit artikel betreft C++23; de compileroptie van de repository bevestigt geen productie-runtime.
Voorbeelden
#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';
}
Resultaat
42
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.