KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

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.

Bronnen