clase ara::core::Result< void, E >

Uso y contexto de llamada

La función miembro Bind de la especialización ara::core::Result<void, E> de ara/core/result.h ejecuta un cálculo posterior sobre una instancia exitosa sin valor de resultado [SWS_CORE_00870]. Si hay un valor presente, se invoca el callable pasado f de forma síncrona y sin parámetros. El callable debe cumplir la interfaz Result<XXX, E> f() o bien XXX f(), debiendo ser XXX un tipo admisible para Result [SWS_CORE_00870]. Si el callable devuelve un Result, el tipo de retorno corresponde a decltype(f()); si devuelve directamente XXX, el resultado se empaqueta como Result<decltype(f()), E> [SWS_CORE_00870].

Tratamiento de errores y concurrencia

Si la instancia no contiene ningún valor, se devuelve un nuevo Result<XXX, E> en el que se copia el error original [SWS_CORE_00870]. Interpretación: en este caso es de prever que no se ejecute el callable f. En cuanto a la seguridad de ejecución, la función se considera not exception safe [SWS_CORE_00870]. La seguridad para subprocesos es condicional (conditional) y depende por completo de la seguridad para subprocesos del callable pasado f [SWS_CORE_00870]. Pregunta Q-6288a7106d2730c3 (abierta)

Interacción con requisitos relacionados

A diferencia de las funciones Result<T, E> primarias de [SWS_CORE_00768] y [SWS_CORE_00941], en las que el callable recibe el valor de la instancia mediante f(const T&), la presente sobrecarga [SWS_CORE_00870] vincula operaciones a resultados void y, por lo tanto, espera un callable sin parámetros.

La función miembro EmplaceError de la especialización ara::core::Result<void, E> construye de forma síncrona un nuevo valor de error directamente in-place dentro de la instancia existente a partir de los argumentos pasados args [SWS_CORE_00844]. La función de plantilla proporcionada a través del archivo de encabezado ara/core/result.h no posee valor de retorno e inicializa el objeto de error del tipo E inmediatamente in situ [SWS_CORE_00844].

En cuanto al tratamiento de errores y la seguridad frente a excepciones, la operación está clasificada como condicionalmente segura frente a excepciones (conditionally exception safe) [SWS_CORE_00844]. Mediante el especificador noexcept(std::is_nothrow_constructible<E, Args...>::value) se garantiza la ausencia de excepciones, siempre que el tipo E pueda construirse con los tipos Args... sin excepciones [SWS_CORE_00844].

En relación con la concurrencia y las condiciones de contorno, la función miembro se define como no segura para subprocesos (not thread-safe) [SWS_CORE_00844]. Si varios subprocesos acceden concurrentemente a la misma instancia de Result, presumiblemente se requiera un mecanismo de sincronización externo para evitar cambios de estado no coordinados. Pregunta Q-ffcb8ced860f6080 (abierta)

En el contexto global del módulo core, [SWS_CORE_00844] se corresponde directamente con las demás variantes de la misma función: para la plantilla primaria ara::core::Result se especifica el comportamiento idéntico en [SWS_CORE_00744], mientras que para tipos de referencia ara::core::Result<T&, E> el requisito [SWS_CORE_00916] establece la misma signatura y semántica.

Uso y contexto de llamada

La función miembro de plantilla EmplaceValue pertenece al módulo core y se define mediante el archivo de encabezado #include "ara/core/result.h" para la especialización ara::core::Result<void, E> [SWS_CORE_00843]. Su propósito es la creación directa o el establecimiento de un nuevo valor en la instancia existente a partir de los argumentos pasados args [SWS_CORE_00843]. La ejecución se realiza de forma síncrona y no proporciona ningún valor de retorno (void) [SWS_CORE_00843]. Dado que el tipo de valor de la especialización es void, la llamada pasa la instancia a un estado de éxito; como interpretación, la recepción de args probablemente sirva principalmente para la compatibilidad genérica de la signatura con la clase de plantilla primaria. Pregunta Q-b53ca5908f2517fb (abierta)

Tratamiento de errores y seguridad frente a excepciones

La función está declarada como noexcept y cuenta con la especificación exception safe [SWS_CORE_00843]. No devuelve códigos de error ni lanza excepciones. Si el objeto Result se encontraba previamente en un estado de error, este se sobrescribe al insertar el valor.

Concurrencia y restricciones

La operación está designada como no segura para subprocesos (not thread-safe) [SWS_CORE_00843]. En caso de accesos de lectura o escritura potencialmente concurrentes a la misma instancia de ara::core::Result, es estrictamente necesaria una sincronización externa por parte del invocador.

Interacción con especificaciones afines

En comparación con la implementación general de EmplaceValue para ara::core::Result<T, E> en [SWS_CORE_00743], que solo es condicionalmente segura frente a excepciones y cuya propiedad noexcept depende de std::is_nothrow_constructible<T, Args...>::value, la especialización void ofrece, según [SWS_CORE_00843], una garantía de noexcept y de seguridad frente a excepciones sin restricciones.

La función miembro Err() const & de la especialización de clase ara::core::Result<void, E> permite consultar de forma síncrona un estado de error posiblemente contenido ([SWS_CORE_00868]). Se declara mediante el archivo de cabecera ara/core/result.h y no requiere parámetros de entrada al llamarse ([SWS_CORE_00868]). Como valor de retorno, la función proporciona un ara::core::Optional<E>, que contiene el valor de error concreto si el objeto representa un error ([SWS_CORE_00868]).

En relación con la concurrencia y las condiciones de contorno, la operación está especificada explícitamente como thread-safe ([SWS_CORE_00868]). En cuanto a la seguridad ante excepciones, el método se considera condicionalmente seguro ante excepciones (conditionally exception safe) ([SWS_CORE_00868]). La garantía noexcept entra en vigor exactamente cuando se cumple std::is_nothrow_constructible<Optional<E>, const E&>::value ([SWS_CORE_00868]).

En el conjunto de interfaces, la sobrecarga rvalue Err() && ([SWS_CORE_00869]) complementa esta función dentro de ara::core::Result<void, E>. También se dispone de pares comparables de sobrecargas lvalue y rvalue para la plantilla primaria ara::core::Result<T, E> ([SWS_CORE_00772], [SWS_CORE_00773]), así como para la especialización de referencia ara::core::Result<T&, E> ([SWS_CORE_00931], [SWS_CORE_00932]).

La función miembro Err() && de la especialización ara::core::Result< void, E > extrae un error eventualmente presente y lo devuelve como ara::core::Optional< E > [SWS_CORE_00869]. Se incluye mediante el archivo de cabecera ara/core/result.h [SWS_CORE_00869].

En cuanto al uso y la semántica, se aplican las siguientes propiedades:

• Contexto de llamada y parámetros: La función no toma parámetros y, como método calificado como rvalue, se vincula exclusivamente a instancias rvalue de ara::core::Result< void, E > [SWS_CORE_00869]. Interpretación: debido a la semántica de rvalue (&&), es probable que el objeto de error se mueva al Optional devuelto durante la llamada. Pregunta Q-b5a0098f77686ca6 (abierta)
• Valor de retorno: El ara::core::Optional< E > resultante contiene el valor de error, siempre que dicho error esté presente en el objeto [SWS_CORE_00869].
• Seguridad ante excepciones y concurrencia: La operación está clasificada como condicionalmente segura ante excepciones (conditionally exception safe) y no lanza excepciones si se cumple std::is_nothrow_constructible< Optional< E >, E && >::value [SWS_CORE_00869]. Además, la función está especificada como segura para subprocesos (thread-safe) [SWS_CORE_00869].

En la interacción de las interfaces, esta variante rvalue complementa la sobrecarga lvalue correspondiente Err() const & de la misma especialización [SWS_CORE_00868]. Existen pares análogos de métodos lvalue y rvalue para la plantilla primaria ara::core::Result [SWS_CORE_00772], [SWS_CORE_00773], así como para la especialización de referencia ara::core::Result< T &, E > [SWS_CORE_00931], [SWS_CORE_00932].

La función miembro de plantilla ErrorOr de la especialización ara::core::Result<void, E> sirve para obtener de forma síncrona el error contenido o un error predeterminado alternativo según [SWS_CORE_00863]. Si la instancia ya contiene un valor de error de tipo E, este se devuelve sin cambios; de lo contrario, el parámetro transferido defaultError se convierte mediante static_cast al tipo de error E y se devuelve [SWS_CORE_00863].

En cuanto al tratamiento de errores y la concurrencia, se aplican las siguientes propiedades:

• Seguridad ante excepciones: La llamada es condicionalmente segura ante excepciones (conditionally exception safe) y está declarada como noexcept, siempre que tanto la construcción de copia de E como la construcción de E a partir del tipo de referencia universal G&& no lancen excepciones (std::is_nothrow_copy_constructible<E>::value && std::is_nothrow_constructible<E, G&&>::value) [SWS_CORE_00863].
• Seguridad para subprocesos: La operación está especificada como segura para subprocesos (thread-safe) [SWS_CORE_00863]. Dado que se trata de una sobrecarga de referencia lvalue constante (const &), los accesos de lectura simultáneos a la misma instancia deberían ser seguros. Pregunta Q-f95402c2e79ef590 (abierta)
• Cabecera: La función se proporciona a través del archivo de cabecera #include "ara/core/result.h" [SWS_CORE_00863].

En la interacción dentro de ara::core::Result, [SWS_CORE_00863] constituye la contrapartida lvalue constante de la sobrecarga rvalue [SWS_CORE_00864] para resultados void, en la cual el error se transfiere a través de std::move. Existen sobrecargas equivalentes para la plantilla de clase primaria Result<T, E> a través de [SWS_CORE_00763] y [SWS_CORE_00764], así como para tipos de referencia Result<T &, E> a través de [SWS_CORE_00935] y [SWS_CORE_00936].

Uso y semántica

La función miembro ErrorOr de la especialización ara::core::Result<void, E> sirve para leer de forma síncrona un error de una instancia rvalue ([SWS_CORE_00864]). Si se llama al método y el objeto Result contiene un error, este se mueve mediante std::move al valor de retorno de tipo E. Si, por el contrario, existe un resultado exitoso, el argumento pasado defaultError se convierte mediante static_cast a E y se devuelve ([SWS_CORE_00864]).

Tratamiento de errores y seguridad frente a excepciones

La función no genera por sí misma mensajes de error clásicos de AUTOSAR como DET o DEM. En cuanto al tratamiento de excepciones, ErrorOr es condicionalmente segura ante excepciones (conditionally exception safe). Está protegida mediante una expresión noexcept, siempre que tanto el tipo de error E pueda moverse sin excepciones (std::is_nothrow_move_constructible<E>::value) como E pueda construirse libre de excepciones a partir del tipo de referencia universal G&& del error predeterminado ([SWS_CORE_00864]).

Concurrencia e interacción

El método está especificado como thread-safe ([SWS_CORE_00864]). Debido al calificador de referencia rvalue &&, la llamada requiere que el objeto Result se transfiera como rvalue.

En el módulo core, esta variante rvalue se combina con otras manifestaciones:

• Para ara::core::Result<void, E> existe como contrapartida lvalue la sobrecarga const & [SWS_CORE_00863], que copia el error en lugar de moverlo.
• Para resultados de valor y de referencia, las especializaciones ara::core::Result<T, E> ([SWS_CORE_00763], [SWS_CORE_00764]) así como ara::core::Result<T&, E> ([SWS_CORE_00935], [SWS_CORE_00936]) ofrecen la misma estructura de firma dual para la semántica de copia y movimiento.

usar

La función estática FromError forma parte de la especialización de plantilla ara::core::Result<void, E> y se incluye a través del archivo de cabecera ara/core/result.h [SWS_CORE_00834]. Sirve como método factoría síncrono para construir un nuevo Result a partir de un objeto de error ya existente [SWS_CORE_00834].

• Parámetro: El parámetro de entrada e recibe el error como referencia lvalue constante (const E &) [SWS_CORE_00834].
• Valor de retorno: Devuelve una instancia de Result que contiene el error proporcionado e [SWS_CORE_00834].

Tratamiento de fallos y seguridad frente a excepciones

La especificación no define códigos de error específicos ni contempla notificaciones a DET o DEM [SWS_CORE_00834]. La función es condicionalmente segura frente a excepciones (conditionally exception safe): se garantiza exactamente como noexcept si el tipo de error E se puede copiar sin lanzar excepciones (std::is_nothrow_copy_constructible<E>::value) [SWS_CORE_00834].

concurrencia

La llamada está catalogada como thread-safe [SWS_CORE_00834]. Interpretación: es probable que la seguridad frente a hilos afecte al proceso interno de creación del objeto, pero presupone que otros hilos no modifiquen el objeto de origen referenciado e durante la operación de copia. Pregunta Q-639cbb5cf8a64a0c (abierta)

Interacción

Dentro de la especialización ara::core::Result<void, E>, sobrecargas para referencias rvalue (E&&) [SWS_CORE_00835], así como para la construcción in-situ mediante parameter pack [SWS_CORE_00836], complementan esta función; ambas están declaradas de manera divergente como not thread-safe. Además, existen sobrecargas correspondientes para el tipo incompletamente especializado ara::core::Result ([SWS_CORE_00734], [SWS_CORE_00735], [SWS_CORE_00736]) y especializaciones de referencia ([SWS_CORE_00905], [SWS_CORE_00906], [SWS_CORE_00907]).

usar

La función estática FromError crea de forma síncrona una nueva instancia de ara::core::Result<void, E> a partir de un objeto de error pasado como rvalue e [SWS_CORE_00835]. La función está definida en la cabecera ara/core/result.h y devuelve un ara::core::Result que contiene el valor de error [SWS_CORE_00835].

Tratamiento de errores y concurrencia

La operación ofrece seguridad condicional frente a excepciones (conditionally exception safe): garantiza la ausencia de excepciones mediante noexcept, siempre que el tipo de error E disponga de un constructor de movimiento que no lance excepciones (std::is_nothrow_move_constructible<E>::value) [SWS_CORE_00835]. La función está clasificada como no segura frente a hilos (not thread-safe) [SWS_CORE_00835]. Interpretación: es probable que esto signifique que el objeto rvalue a mover debe protegerse frente a accesos paralelos desde otros hilos. Pregunta Q-be29e8c3a7412b7a (abierta)

Interacción

Dentro de la especialización ara::core::Result<void, E>, esta sobrecarga representa la contraparte por movimiento frente a la función de copia por lvalue [SWS_CORE_00834] y a la construcción in-situ mediante parameter packs [SWS_CORE_00836]. En el módulo core también existen sobrecargas por rvalue comparables para tipos por valor [SWS_CORE_00735] y referencias [SWS_CORE_00906], complementadas por las respectivas variantes por lvalue ([SWS_CORE_00734], [SWS_CORE_00905]) e in-situ ([SWS_CORE_00736], [SWS_CORE_00907]).

La función de plantilla estática FromError conforme a [SWS_CORE_00836] sirve para crear, dentro de la especialización ara::core::Result<void, E>, un objeto Result que contiene un error, cuya instancia de error del tipo E se construye directamente in-situ («in-place») a partir de los argumentos suministrados args. La función solo participa en la resolución de sobrecargas si std::is_constructible<E, Args&&...>::value es verdadero, el primer tipo del parameter pack desempaquetado no corresponde a E y tampoco es una especialización de Result [SWS_CORE_00836].

En cuanto a la seguridad frente a excepciones, la función está especificada como condicionalmente segura frente a excepciones («conditionally exception safe»): está declarada con noexcept(std::is_nothrow_constructible<E, Args...>::value) [SWS_CORE_00836]. En lo relativo a la concurrencia, la invocación se considera no segura frente a hilos («not thread-safe») [SWS_CORE_00836].

En interacción con otras funciones de la clase, este método complementa las sobrecargas para la creación a partir de objetos de error lvalue ([SWS_CORE_00834]) o rvalue ([SWS_CORE_00835]) ya existentes. Interpretación: es probable que las restricciones SFINAE respecto a E y Result aseguren que, al pasar errores o instancias de Result ya creados, se seleccionen preferentemente los respectivos operadores de copia o de movimiento y se eviten ambigüedades. Pregunta Q-2796f954bcaececa (abierta) Existen funciones factoría in-situ análogas para el tipo genérico Result ([SWS_CORE_00736]), así como para tipos de referencia en Result<T&, E> ([SWS_CORE_00907]).

usar

La función miembro estática FromValue() sirve para crear un objeto ara::core::Result exitoso para la especialización de plantilla ara::core::Result<void, E> [SWS_CORE_00831]. Dado que el tipo de resultado void no transporta datos útiles, la función no acepta parámetros de entrada. La llamada se realiza de forma síncrona y devuelve un Result que representa un valor void [SWS_CORE_00831]. La declaración se realiza en el encabezado ara/core/result.h [SWS_CORE_00831].

Tratamiento de errores y seguridad frente a excepciones

La función cuenta con la especificación noexcept y está clasificada como totalmente segura frente a excepciones (exception safe) [SWS_CORE_00831]. Dado que FromValue() representa por definición una operación exitosa, no genera estados de error ni devuelve códigos de error. No se han definido mensajes de error específicos a través de DET o DEM para esta llamada.

concurrencia

Según la especificación, la función está clasificada como segura para subprocesos (thread-safe) [SWS_CORE_00831]. Puede llamarse en paralelo desde múltiples subprocesos sin medidas de sincronización adicionales.

Interacción

La signatura sin parámetros está prevista exclusivamente para Result<void, E> [SWS_CORE_00831]. Se distingue de las sobrecargas generadoras de valor:

• Para tipos de valor Result<T, E> existen variantes para lvalues [SWS_CORE_00731], rvalues [SWS_CORE_00732], así como construcciones in-place [SWS_CORE_00733].
• Para tipos de referencia Result<T&, E>, FromValue se vincula a una referencia lvalue [SWS_CORE_00904].

La función miembro Resolve de la clase de plantilla ara::core::Result<void, E> sirve para el tratamiento de errores en el marco de la programación genérica [SWS_CORE_00867]. Si la instancia de Result contiene un valor regular, la llamada no ejecuta ninguna operación [SWS_CORE_00867]. Si, en su lugar, la instancia contiene un error, se invoca el callable f pasado como parámetro [SWS_CORE_00867].

El callable f pasado debe ser compatible con la signatura de función void f(const E&), donde E representa el tipo de error [SWS_CORE_00867]. La propia función Resolve no devuelve ningún valor (void) [SWS_CORE_00867]. En cuanto a la seguridad de ejecución, la función está especificada como no segura frente a excepciones («not exception safe») [SWS_CORE_00867]. Su seguridad para subprocesos es condicional y depende directamente de la seguridad para subprocesos del callable f pasado [SWS_CORE_00867].

En el sistema global, esta especialización se distingue de las funciones Resolve regulares para tipos de valor en ara::core::Result<T, E> [SWS_CORE_00767], así como para tipos de referencia en ara::core::Result<T&, E> [SWS_CORE_00939], [SWS_CORE_00940]: mientras que aquellas variantes devuelven el valor contenido o el resultado de la llamada al callable, la sobrecarga void sin valor de retorno existe exclusivamente como componente genérico para la unificación de llamadas a interfaces [SWS_CORE_00867].

La función miembro Swap intercambia el contenido de la instancia actual de forma síncrona con la referencia pasada other [SWS_CORE_00845]. Pertenece al ámbito de la especialización ara::core::Result<void, E> del archivo de encabezado ara/core/result.h y no posee valor de retorno [SWS_CORE_00845].

En cuanto al tratamiento de errores, la operación está clasificada como condicionalmente segura frente a excepciones (conditionally exception safe) [SWS_CORE_00845]. La garantía noexcept se aplica exactamente cuando el tipo de error E es tanto construible por movimiento sin excepciones (std::is_nothrow_move_constructible<E>::value) como asignable por movimiento sin excepciones (std::is_nothrow_move_assignable<E>::value) [SWS_CORE_00845]. No están previstos códigos de error específicos ni notificaciones a DET o DEM para esta llamada [SWS_CORE_00845].

Respecto a la concurrencia, Swap está especificada expresamente como no segura para subprocesos (not thread-safe) [SWS_CORE_00845]. Por lo tanto, es probable que el acceso concurrente a las mismas instancias sin sincronización externa dé lugar a condiciones de carrera de datos. Pregunta Q-a8d4f130648765df (abierta)

En la interacción dentro de ara::core, el método constituye la base para la función de plantilla libre ara::core::swap, cuya condición noexcept está vinculada directamente a la función miembro [SWS_CORE_00796]. Existen operaciones de intercambio comparables para el tipo genérico ara::core::Result<T, E> [SWS_CORE_00745], la especialización de referencia ara::core::Result<T&, E> [SWS_CORE_00917], así como para objetos Promise [SWS_CORE_00352] [SWS_CORE_06352].

La función miembro ValueOr de la especialización ara::core::Result<void, E> sirve primordialmente para facilitar patrones de programación genérica y no realiza ninguna operación al ejecutarse ([SWS_CORE_00861]). Proporcionado mediante el encabezado ara/core/result.h, el método acepta de forma síncrona un parámetro defaultValue del tipo de reenvío U&& y no devuelve ningún valor (void) ([SWS_CORE_00861]).

En cuanto a la concurrencia y el comportamiento ante excepciones, la función miembro está especificada como segura para subprocesos (thread-safe) y declarada con la sintaxis del especificador noexcept, lo que garantiza una seguridad total frente a excepciones ([SWS_CORE_00861]). Dado que no se realiza ninguna comprobación del estado de error ni ninguna acción, no existen ni códigos de error ni avisos a DET o DEM.

En interacción con las demás variantes de Result, esta función complementa las sobrecargas basadas en valores ([SWS_CORE_00761], [SWS_CORE_00762]) y basadas en referencias ([SWS_CORE_00933], [SWS_CORE_00934]) de ValueOr. Mientras que aquellas funciones devuelven el valor establecido si está presente o, de lo contrario, entregan el valor de sustitución pasado convertido, esta variante representa una contrapartida neutra para operaciones sin retorno de valor ([SWS_CORE_00861]). Interpretación: es probable que el valor pasado defaultValue se descarte sin usar en la implementación. Pregunta Q-6097af779219e859 (abierta) Esto permite a los desarrolladores escribir algoritmos de plantilla genéricos sin ramificaciones especiales para Result<void, E>.

La función miembro ValueOrThrow de la especialización de plantilla ara::core::Result<void, E> sirve para la comprobación síncrona del resultado de la operación [SWS_CORE_00866]. Dado que el tipo de valor es void, la función no posee parámetros y no devuelve ningún valor [SWS_CORE_00866]. La declaración se proporciona a través de la cabecera ara/core/result.h [SWS_CORE_00866].

En caso de éxito, el método retorna normalmente; si, por el contrario, existe un estado de error, lanza una excepción del tipo de excepción vinculado al error contenido (noexcept(false)) [SWS_CORE_00866]. En lo relativo a la seguridad ante excepciones, la operación está especificada como not exception safe [SWS_CORE_00866].

Para el contexto de llamada y la concurrencia se aplican las siguientes condiciones límite:

• La función está clasificada como thread-safe [SWS_CORE_00866].
• Si las excepciones de C++ están desactivadas en la cadena de herramientas del compilador, esta función no participa en la resolución de sobrecargas [SWS_CORE_00866].

En interacción con el módulo core, esta especialización void complementa las sobrecargas genéricas de ara::core::Result<T, E> que devuelven referencias a valores contenidos ([SWS_CORE_00766], [SWS_CORE_00769], [SWS_CORE_00778]), así como las especializaciones para tipos de referencia ara::core::Result<T&, E> ([SWS_CORE_00938], [SWS_CORE_00949]).

La función miembro de plantilla CheckError de la especialización ara::core::Result<void, E> comprueba de forma síncrona si la instancia actual contiene un error determinado [SWS_CORE_00865]. Para ello, el argumento pasado error se convierte mediante static_cast al tipo de error E y se compara con el valor de retorno del estado de error interno Error() [SWS_CORE_00865]. La llamada se realiza a través del encabezado #include "ara/core/result.h" [SWS_CORE_00865].

Para el uso y el contexto de invocación se aplican las siguientes propiedades:

• Parámetro y valor de retorno: el parámetro de referencia universal error de tipo G&& recibe el error que se va a comprobar [SWS_CORE_00865]. La función devuelve true si la instancia contiene un error equivalente a error; de lo contrario, false [SWS_CORE_00865].
• Concurrencia y seguridad frente a excepciones: la operación está declarada como const noexcept, se considera segura frente a excepciones (exception safe) y puede invocarse sin restricciones de forma segura para subprocesos (thread-safe) [SWS_CORE_00865].

En interacción con el módulo core existen sobrecargas análogas de CheckError: la clase de plantilla primaria ara::core::Result proporciona la misma signatura asimismo de forma segura para subprocesos y frente a excepciones con noexcept [SWS_CORE_00765]. Por el contrario, la especialización de referencia ara::core::Result<T&, E>, si bien cuenta con el mismo mecanismo de comparación y es segura para subprocesos, está especificada explícitamente sin noexcept como no segura frente a excepciones (not exception safe) [SWS_CORE_00937].