Usando std::apply en std::expected en C++23

Usando std::apply en std::expected en C++23
Usando std::apply en std::expected en C++23
Lina Fontaine
Miércoles, 18 de septiembre de 2024, 19:27:00

Optimización del manejo de errores en C++23

Manejar eficazmente los errores y gestionar los valores de retorno es esencial en el desarrollo actual de C++. El método típico de trabajar con funciones que devuelven tipos {std::expected} incluye muchas comprobaciones y código de manejo de errores, lo que puede complicar la lógica y hacer que el código sea más difícil de mantener.

Este artículo investiga el uso de un método más sofisticado y general para simplificar la gestión de errores. Para reducir el código repetitivo y mejorar la legibilidad, investigaremos la construcción de un método `magic_apply` que agregue los resultados de muchos valores {std::expected} y los pase a otra función.

Dominio Descripción
std::expected Un tipo de plantilla utilizado en C++ para el manejo de errores que tiene la capacidad de almacenar tanto valores como errores.
std::unexpected Cuando se usa con std::expected, representa un valor de error inesperado.
template<typename...> Describe una plantilla variada con una cantidad infinita de argumentos de plantilla que puede aceptar.
decltype Se utiliza en programación de plantillas, especialmente para conocer el tipo de expresión.
args.value() Si un objeto std::expected tiene un valor, accede al valor contenido en él.
args.has_value() Verifica si un valor está presente en un objeto std::expected.
(... && args.has_value()) Para determinar si cada objeto std::expected tiene valores, doble la expresión.
func(args.value()...) Utiliza los valores de los objetos std::expected para llamar al método func.
return unexpected<Err>(args.error()...) Devuelve un error inesperado que contiene los errores de los objetos std::expected.

Gestión eficaz de errores mediante plantillas variables

El std::expected El tipo se utiliza en los scripts para facilitar el manejo de errores en C++23. El objetivo principal es desarrollar una función genérica llamada magic_apply que puede transmitir la salida de varios std::expected valores a otra función. Al hacer esto, se elimina la tediosa comprobación de errores que suele ser necesaria cuando se trabaja con muchos std::expected los valores se reducen. magic_apply es bastante flexible porque puede requerir cualquier número de std::expected parámetros utilizando plantillas variadas. Antes de llamar a la función con el contenido de cualquier std::expected objeto, la lógica fundamental de magic_apply emplea una expresión de pliegue, (... && args.has_value()), para asegurarse de que todos std::expected Los objetos tienen valores válidos.

Esta idea se ilustra en el primer ejemplo de script utilizando tipos simples como int y double. Define un compute_all función que lleva a cabo un cálculo básico, y getA y getB funciones que regresan std::expected tipos. Si ambos valores de getA y getB son legítimos, podemos llamar compute_all usando magic_apply; si no, el error se propaga. Al reducir el código repetitivo, este método mejora la legibilidad y el mantenimiento. En el segundo guión se presenta una idea similar, pero para resaltar la versatilidad del enfoque, string tipos y lambda functions se utilizan.

Reducción de la complejidad en el manejo de errores de C++ con `std::expected}

Script C++23 usando plantillas variadas

#include <expected>
#include <string>
#include <iostream>
#include <tuple>

using namespace std;

template<typename Func, typename... Args, typename Err>
auto magic_apply(Func func, const expected<Args, Err>&... args) -> expected<decltype(func(args.value()...)), Err> {
    if ((... && args.has_value())) {
        return func(args.value()...);
    } else {
        return unexpected<Err>(args.error()...);
    }
}

expected<int, string> getA(int x) {
    if (x > 0) return x;
    return unexpected<string>("Error in getA");
}

expected<double, string> getB(double y) {
    if (y > 0) return y;
    return unexpected<string>("Error in getB");
}

double compute_all(int a, double b) {
    return a + b;
}

int main() {
    auto result = magic_apply(compute_all, getA(10), getB(20.5));
    if (result) {
        cout << "Result: " << result.value() << endl;
    } else {
        cout << "Error: " << result.error() << endl;
    }
    return 0;
}

Combinando diferentes valores de C++23 de resultados {std::expected}

Script C++ 23 que utiliza funciones Lambda

#include <expected>
#include <string>
#include <iostream>

using namespace std;

template<typename Func, typename... Args, typename Err>
auto magic_apply(Func func, const expected<Args, Err>&... args) -> expected<decltype(func(args.value()...)), Err> {
    bool all_valid = (args.has_value() && ...);
    if (all_valid) {
        return func(args.value()...);
    } else {
        return unexpected<Err>(args.error()...);
    }
}

expected<string, string> getA(bool flag) {
    if (flag) return "SuccessA";
    return unexpected<string>("Failed A");
}

expected<string, string> getB(bool flag) {
    if (flag) return "SuccessB";
    return unexpected<string>("Failed B");
}

string compute_all(const string& a, const string& b) {
    return a + " and " + b;
}

int main() {
    auto result = magic_apply(compute_all, getA(true), getB(true));
    if (result) {
        cout << "Result: " << result.value() << endl;
    } else {
        cout << "Error: " << result.error() << endl;
    }
    return 0;
}

Mejora del manejo de errores de C++ con plantillas variadas

la capacidad de std::expected Mejorar enormemente el manejo de errores en sistemas complejos es otro beneficio crucial de emplearlo en C++. Combinar perfectamente los resultados de muchas acciones asincrónicas es esencial en situaciones en las que producen std::expected tipos. Además de simplificar el código, este método garantiza un sólido manejo de errores. Se pueden crear funciones más versátiles y genéricas combinando un número arbitrario de std::expected valores con variadic templates.

La versatilidad de magic_apply permite usarlo con funciones que aceptan una variedad de tipos de argumentos. La implementación se simplifica aún más utilizando decltype, que deduce automáticamente el tipo de retorno de la llamada a la función combinada. Además, esta técnica se puede ampliar para gestionar tareas más complejas, incluida la fusión std::expected valores con otros tipos de error o alterar los valores antes de enviarlos a la función. Debido a su adaptabilidad, el patrón se puede utilizar para una amplia gama de tareas, desde cálculos sencillos hasta operaciones complejas.

Preguntas frecuentes sobre plantillas variadas y std::expected

  1. Qué es std::expected?
  2. Es un tipo de plantilla de C++ que puede contener un error o un valor válido y se utiliza para la gestión de errores.
  3. ¿Cómo magic_apply ¿trabajar?
  4. Elimina la necesidad de realizar repetidas comprobaciones de errores al combinar los resultados de numerosos std::expected valores y pasarlos a una función.
  5. ¿Qué son las plantillas variadas?
  6. Las plantillas variables ofrecen una gran libertad en el diseño de funciones al permitir que las funciones acepten una cantidad arbitraria de parámetros.
  7. ¿Por qué usar? decltype en magic_apply?
  8. Utilizando los valores de la std::expected objetos para determinar automáticamente el tipo de retorno de la función que se llama.
  9. Es magic_apply ¿Capaz de manejar varios tipos de errores?
  10. Sí, se puede hacer que funcione con std::expected valores que tienen varios tipos de errores con algunos ajustes.
  11. ¿Qué ventajas tiene utilizar? std::expected ¿oferta?
  12. Al manejar errores, ofrece un enfoque más expresivo y limpio que con técnicas más convencionales como excepciones o códigos de retorno.
  13. Es std::unexpected parte de std::expected?
  14. Además de std::expected, std::unexpected De hecho, representa un valor incorrecto.
  15. ¿Se pueden utilizar acciones asincrónicas con magic_apply?
  16. De hecho, es adaptable para manejar std::expected valores devueltos por operaciones asincrónicas.
  17. ¿Qué es una expresión plegable?
  18. Aquí, la característica en C++ llamada expresión de plegado se usa para verificar si todos std::expected Los objetos contienen valores válidos de una manera sencilla.

Concluyendo:

En C++23, implementar una función genérica para manejar múltiples valores std::expected mejora enormemente la legibilidad del código y simplifica enormemente el manejo de errores. La función magic_apply reduce el código repetitivo y mejora la capacidad de mantenimiento mediante el uso de plantillas variadas para garantizar que todos los valores anticipados sean correctos antes del procesamiento. Este método ofrece una solución flexible que se puede aplicar a diferentes situaciones y brinda a la programación C++ moderna una forma más limpia y efectiva de manejar fallas.