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.