Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Atomowy zapis i odczyt shared_ptr przez funkcje wolnostojące

Przeciążenia std::atomic_store_explicit i std::atomic_load_explicit dla std::shared_ptr pozwalają atomowo podmieniać i pobierać współdzielony uchwyt. W C++23 są przestarzałe; chronią uchwyt i własność, a nie dowolne operacje na wskazywanym obiekcie.

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

Składnia

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

W C++23 funkcje z <memory> operują na zwykłym obiekcie std::shared_ptr<T>, a nie na std::atomic<T>. std::atomic_store_explicit(std::shared_ptr<T>*, ...) atomowo zastępuje uchwyt wartością desired i zwraca void. std::atomic_load_explicit(const std::shared_ptr<T>*, ...) atomowo zwraca kopię uchwytu, która podtrzymuje współwłasność. Wskaźnik p musi wskazywać istniejący obiekt; odczyt może zwrócić pusty uchwyt.

Parametr order określa porządek pamięci. Dla zapisu dozwolone są std::memory_order_relaxed, std::memory_order_release i std::memory_order_seq_cst. Dla odczytu w C++23: std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire i std::memory_order_seq_cst. Inny porządek oznacza niezdefiniowane zachowanie. Odczyt acquire, który odczytuje wartość opublikowaną zapisem release, zapewnia widoczność wcześniejszej inicjalizacji; relaxed sam nie zapewnia takiej synchronizacji.

Nie mieszaj tych operacji ze zwykłym przypisaniem, reset() ani kopiowaniem tego samego uchwytu, jeśli dostęp może być współbieżny z zapisem: grozi to wyścigiem danych. Atomowość uchwytu nie chroni modyfikacji *snapshot; te wymagają osobnej synchronizacji. Nie zakładaj też działania bez blokad. Zachowaj obiekt slot przy życiu przez cały czas dostępu.

To historyczny interfejs, przestarzały od C++20 i usunięty w C++26. Bieżący adres dostarczonego rozdziału informuje jedynie o usunięciu; nie jest migawką C++23. Zastępstwem jest std::atomic<std::shared_ptr<T>> z metodami store() i load(), które wyrażają atomowy dostęp w typie. Zakres wpisu to C++23; flaga kompilatora repozytorium nie potwierdza środowiska produkcyjnego.

Przykłady

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

Wynik

42

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła