База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / C++

Атомарно записване и зареждане на shared_ptr чрез свободни функции

Претоварванията на std::atomic_store_explicit и std::atomic_load_explicit за std::shared_ptr атомарно заменят и прочитат стойността на интелигентен указател със споделена собственост. В C++23 те са остарели; защитават самия указател и споделената собственост, но не и произволни операции върху обекта, към който сочи указателят.

Версия: C++23; repository compiler flag, production runtime not attested

Синтаксис

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

В C++23 тези функции от <memory> работят с обикновен обект std::shared_ptr<T>, а не с std::atomic<T>. std::atomic_store_explicit(std::shared_ptr<T>*, ...) атомарно заменя стойността на интелигентния указател с desired и връща void. std::atomic_load_explicit(const std::shared_ptr<T>*, ...) атомарно връща копие на обекта std::shared_ptr<T>, което запазва споделената собственост. Указателят p трябва да сочи към жив обект; зареждането може да върне празен std::shared_ptr<T>.

Параметърът order избира реда на паметта. За запис са разрешени std::memory_order_relaxed, std::memory_order_release и std::memory_order_seq_cst. За зареждане в C++23 са разрешени std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire и std::memory_order_seq_cst. Други редове водят до недефинирано поведение. Зареждане acquire, което прочита стойността, публикувана чрез запис release, прави видима предходната инициализация; relaxed само по себе си не осигурява тази синхронизация.

Не смесвайте тези операции с обикновено присвояване, reset() или копиране на същия обект std::shared_ptr<T>, когато достъпът може да се застъпва със запис: това крие риск от състезание за данни. Атомарният достъп до интелигентния указател не защитава промените по *snapshot; за тях е необходима отделна синхронизация. Не приемайте и че операцията е без заключване. Обектът slot трябва да остане жив през целия период на достъп.

Това е исторически интерфейс, остарял от C++20 и премахнат в C++26. Текущият адрес на предоставения раздел само съобщава за премахването; той не е моментна снимка на C++23. Замяната е std::atomic<std::shared_ptr<T>> с методите store() и load(), които изразяват атомарния достъп в типа. Този запис се отнася за C++23; флагът на компилатора в хранилището не удостоверява производствена среда за изпълнение.

Примери

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

Резултат

42

Показаният код и заявеният резултат са проверени в изолирана среда по метода, записан в доказателството за проверка на тази точна версия.

Източници