Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Lecturas y escrituras atómicas de shared_ptr mediante funciones libres

Las sobrecargas para std::shared_ptr de std::atomic_store_explicit y std::atomic_load_explicit reemplazan y obtienen atómicamente un manejador compartido. Están obsoletas en C++23; protegen el manejador y la propiedad, no las operaciones arbitrarias sobre el objeto apuntado.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#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, estas funciones de <memory> operan sobre un objeto ordinario std::shared_ptr<T>, no sobre un std::atomic<T>. std::atomic_store_explicit(std::shared_ptr<T>*, ...) reemplaza atómicamente el manejador por desired y devuelve void. std::atomic_load_explicit(const std::shared_ptr<T>*, ...) devuelve atómicamente una copia del manejador que conserva la propiedad compartida. El puntero p debe designar un objeto vivo; una lectura puede devolver un manejador vacío.

El parámetro order selecciona el orden de memoria. Para las escrituras se permiten std::memory_order_relaxed, std::memory_order_release y std::memory_order_seq_cst. En C++23, para las lecturas se permiten std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire y std::memory_order_seq_cst. Otros órdenes provocan comportamiento indefinido. Una lectura acquire que lee el valor publicado por una escritura release hace visible la inicialización anterior; relaxed por sí solo no proporciona esa sincronización.

No combines estas operaciones con una asignación ordinaria, reset() o la copia del mismo manejador cuando el acceso pueda coincidir con una escritura: existe riesgo de una carrera de datos. La atomicidad del manejador no protege las modificaciones de *snapshot; estas requieren sincronización aparte. Tampoco des por hecho que la operación no usa bloqueos. Mantén vivo el objeto slot durante todos los accesos.

Esta es una interfaz heredada, obsoleta desde C++20 y eliminada en C++26. La dirección actual de la sección proporcionada solo informa de su eliminación; no es una instantánea de C++23. La alternativa es std::atomic<std::shared_ptr<T>> con los métodos store() y load(), que expresan el acceso atómico en el tipo. Esta entrada se refiere a C++23; la opción del compilador del repositorio no acredita un entorno de producción.

Ejemplos

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

Resultado

42

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes