Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

Atomické ukládání a načítání shared_ptr pomocí volných funkcí

Přetížení std::atomic_store_explicit a std::atomic_load_explicit pro std::shared_ptr umožňují atomicky nahradit a načíst hodnotu sdíleného ukazatele. V C++23 jsou zastaralá; chrání samotný ukazatel a sdílené vlastnictví, nikoli libovolné operace s objektem, na který ukazatel odkazuje.

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

Syntaxe

#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 tyto funkce z <memory> pracují s obyčejným objektem std::shared_ptr<T>, nikoli s std::atomic<T>. std::atomic_store_explicit(std::shared_ptr<T>*, ...) atomicky nahradí hodnotu sdíleného ukazatele hodnotou desired a vrátí void. std::atomic_load_explicit(const std::shared_ptr<T>*, ...) atomicky načte a vrátí kopii sdíleného ukazatele, která zachová sdílené vlastnictví. Ukazatel p musí ukazovat na objekt, jehož doba života dosud neskončila; načtení může vrátit prázdný sdílený ukazatel.

Parametr order určuje pořadí paměti. Pro zápis jsou povoleny std::memory_order_relaxed, std::memory_order_release a std::memory_order_seq_cst. Pro načítání jsou v C++23 povoleny std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire a std::memory_order_seq_cst. Jiná pořadí způsobují nedefinované chování. Načtení acquire, které přečte hodnotu zveřejněnou zápisem release, zviditelní předchozí inicializaci; samotné relaxed tuto synchronizaci neposkytuje.

Nekombinujte tyto operace s běžným přiřazením, voláním reset() ani kopírováním téhož objektu std::shared_ptr, pokud se přístup může překrývat se zápisem: hrozí datový závod. Atomicita přístupu k samotnému sdílenému ukazateli nechrání změny *snapshot; ty vyžadují samostatnou synchronizaci. Nepředpokládejte ani provádění bez zámků. Objekt slot musí zůstat živý po celou dobu přístupu.

Jde o historické rozhraní, zastaralé od C++20 a odstraněné v C++26. Aktuální adresa dodané části pouze oznamuje odstranění; nejde o snímek C++23. Náhradou je std::atomic<std::shared_ptr<T>> s metodami store() a load(), které vyjadřují atomický přístup v typu. Tento záznam se vztahuje k C++23; příznak kompilátoru v repozitáři nepotvrzuje produkční běhové prostředí.

Příklady

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

Výsledek

42

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje