Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Chargements et stockages atomiques de shared_ptr par fonctions libres

Les surcharges pour std::shared_ptr de std::atomic_store_explicit et std::atomic_load_explicit remplacent et récupèrent atomiquement un handle partagé. Dépréciées en C++23, elles protègent le handle et la propriété partagée, pas les opérations arbitraires sur l’objet pointé.

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

En C++23, ces fonctions de <memory> agissent sur un objet ordinaire std::shared_ptr<T>, et non sur un std::atomic<T>. std::atomic_store_explicit(std::shared_ptr<T>*, ...) remplace atomiquement le handle par desired et renvoie void. std::atomic_load_explicit(const std::shared_ptr<T>*, ...) renvoie atomiquement une copie du handle qui conserve la propriété partagée. Le pointeur p doit désigner un objet vivant ; un chargement peut renvoyer un handle vide.

Le paramètre order définit l’ordre mémoire. Les stockages autorisent std::memory_order_relaxed, std::memory_order_release et std::memory_order_seq_cst. En C++23, les chargements autorisent std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire et std::memory_order_seq_cst. Tout autre ordre entraîne un comportement indéfini. Un chargement acquire qui lit la valeur publiée par un stockage release rend visible l’initialisation antérieure ; relaxed seul n’assure pas cette synchronisation.

Ne mélangez pas ces opérations avec une affectation ordinaire, reset() ou la copie du même handle lorsque les accès peuvent se chevaucher avec une écriture : cela risque de créer une course de données. L’atomicité du handle ne protège pas les modifications de *snapshot ; celles-ci nécessitent une synchronisation distincte. Ne supposez pas non plus que l’opération est sans verrou. L’objet slot doit rester vivant pendant toute la durée des accès.

Il s’agit d’une interface historique, dépréciée depuis C++20 et supprimée en C++26. L’adresse actuelle de la section fournie indique uniquement sa suppression ; ce n’est pas un instantané de C++23. Le remplacement est std::atomic<std::shared_ptr<T>> avec les méthodes store() et load(), qui expriment l’accès atomique dans le type. Cette entrée concerne C++23 ; l’option du compilateur du dépôt n’atteste pas la prise en charge d’un environnement de production.

Exemples

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

Résultat

42

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources