WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Atomare shared_ptr-Zugriffe über freie Funktionen

Die std::shared_ptr-Überladungen von std::atomic_store_explicit und std::atomic_load_explicit ersetzen beziehungsweise lesen einen gemeinsam genutzten Handle atomar. In C++23 sind sie veraltet; geschützt werden Handle und Besitz, nicht beliebige Operationen auf dem referenzierten Objekt.

Version: 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 arbeiten diese Funktionen aus <memory> mit einem gewöhnlichen Objekt std::shared_ptr<T>, nicht mit einem std::atomic<T>. std::atomic_store_explicit(std::shared_ptr<T>*, ...) ersetzt den Handle atomar durch desired und gibt void zurück. std::atomic_load_explicit(const std::shared_ptr<T>*, ...) gibt atomar eine Handle-Kopie zurück, die den gemeinsamen Besitz aufrechterhält. Der Zeiger p muss auf ein lebendes Objekt zeigen; ein Lesezugriff kann einen leeren Handle zurückgeben.

Der Parameter order legt die Speicherordnung fest. Für Schreibzugriffe sind std::memory_order_relaxed, std::memory_order_release und std::memory_order_seq_cst zulässig. Für Lesezugriffe sind in C++23 std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire und std::memory_order_seq_cst zulässig. Andere Ordnungen führen zu undefiniertem Verhalten. Ein Acquire-Lesezugriff, der den von einem Release-Schreibzugriff veröffentlichten Wert liest, macht die vorherige Initialisierung sichtbar; relaxed allein bietet diese Synchronisierung nicht.

Mische diese Operationen nicht mit gewöhnlicher Zuweisung, reset() oder dem Kopieren desselben Handles, wenn Zugriffe mit einem Schreibzugriff überlappen können: Das birgt das Risiko eines Datenrennens. Die Atomarität des Handles schützt Änderungen an *snapshot nicht; dafür ist eine separate Synchronisierung erforderlich. Gehe auch nicht von einer sperrenfreien Ausführung aus. Das Objekt slot muss während des gesamten Zugriffslebens bestehen bleiben.

Dies ist eine historische Schnittstelle, die seit C++20 veraltet und in C++26 entfernt ist. Die aktuelle Adresse des bereitgestellten Abschnitts meldet lediglich die Entfernung; sie ist kein C++23-Snapshot. Der Ersatz ist std::atomic<std::shared_ptr<T>> mit den Methoden store() und load(), die atomaren Zugriff im Typ ausdrücken. Dieser Eintrag bezieht sich auf C++23; das Compiler-Flag des Repositorys bestätigt keine Produktionslaufzeit.

Beispiele

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

Ergebnis

42

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen