Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Atomsko spremanje i učitavanje shared_ptr-a pomoću slobodnih funkcija

Preopterećenja std::atomic_store_explicit i std::atomic_load_explicit za std::shared_ptr atomski zamjenjuju i učitavaju vrijednost pametnog pokazivača sa zajedničkim vlasništvom. U C++23 su zastarjela; štite pametni pokazivač i zajedničko vlasništvo, a ne proizvoljne operacije nad objektom na koji pokazuje.

Verzija: 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.

U C++23 ove funkcije iz <memory> rade s običnim objektom std::shared_ptr<T>, a ne s std::atomic<T>. std::atomic_store_explicit(std::shared_ptr<T>*, ...) atomski zamjenjuje vrijednost pametnog pokazivača vrijednošću desired i vraća void. std::atomic_load_explicit(const std::shared_ptr<T>*, ...) atomski vraća kopiju objekta std::shared_ptr<T> koja zadržava zajedničko vlasništvo. Pokazivač p mora označavati živi objekt; učitavanje može vratiti prazan std::shared_ptr<T>.

Parametar order određuje redoslijed memorije. Za pohranu su dopušteni std::memory_order_relaxed, std::memory_order_release i std::memory_order_seq_cst. Za učitavanje su u C++23 dopušteni std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire i std::memory_order_seq_cst. Drugi redoslijedi uzrokuju nedefinirano ponašanje. Učitavanje acquire koje pročita vrijednost objavljenu pohranom release čini vidljivom prethodnu inicijalizaciju; relaxed sam ne osigurava tu sinkronizaciju.

Nemojte miješati ove operacije s običnom dodjelom, reset() ili kopiranjem istog objekta std::shared_ptr<T> ako se pristup može preklapati sa zapisivanjem: postoji rizik od utrke podataka. Atomski pristup pametnom pokazivaču ne štiti izmjene *snapshot; za njih je potrebna zasebna sinkronizacija. Nemojte pretpostaviti ni da se operacija izvodi bez zaključavanja. Objekt slot mora ostati živ tijekom svih pristupa.

Ovo je povijesno sučelje, zastarjelo od C++20 i uklonjeno u C++26. Trenutačna adresa dostavljenog odjeljka samo navodi uklanjanje; nije snimka C++23. Zamjena je std::atomic<std::shared_ptr<T>> s metodama store() i load(), koje izražavaju atomski pristup u tipu. Ovaj se zapis odnosi na C++23; oznaka prevoditelja u repozitoriju ne potvrđuje produkcijsko izvršno okruženje.

Primjeri

#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

Prikazani kôd i navedeni rezultat provjereni su u izoliranom okruženju metodom zabilježenom u dokazu provjere za ovu točnu verziju.

Izvori