Używanie std::apply na std::expected w C++ 23

Usprawnienie obsługi błędów w C++23

Skuteczne radzenie sobie z błędami i zarządzanie wartościami zwracanymi jest niezbędne w dzisiejszym rozwoju C++. Typowa metoda pracy z funkcjami zwracającymi typy {std::expected} obejmuje wiele kontroli i kodu obsługi błędów, co może skomplikować logikę i sprawić, że kod będzie trudniejszy w utrzymaniu.

W artykule zbadano zastosowanie bardziej wyrafinowanej i ogólnej metody upraszczającej zarządzanie błędami. Aby zredukować szablonowy kod i poprawić czytelność, zbadamy konstrukcję metody `magic_apply`, która agreguje wyniki wielu wartości {std::expected} i przekazuje je do innej funkcji.

Rozkaz	Opis
std::expected	Typ szablonu używany w języku C++ do obsługi błędów, który umożliwia przechowywanie zarówno wartości, jak i błędów.
std::unexpected	W przypadku użycia z std::expected reprezentuje nieoczekiwaną wartość błędu.
template<typename...>	Przedstawia szablon variadic z nieskończoną liczbą argumentów szablonu, które może zaakceptować.
decltype	Używane w programowaniu szablonowym, szczególnie w celu sprawdzenia typu wyrażenia.
args.value()	Jeśli obiekt std::expected ma wartość, uzyskuje dostęp do wartości w nim zawartej.
args.has_value()	Sprawdza, czy wartość występuje w obiekcie std::expected.
(... && args.has_value())	Aby ustalić, czy każdy obiekt std::expected ma wartości, złóż wyrażenie.
func(args.value()...)	Używa wartości obiektów std::expected do wywołania metody func.
return unexpected<Err>(args.error()...)	Zwraca nieoczekiwany błąd zawierający błędy z obiektów std::expected.

Efektywne zarządzanie błędami przy użyciu szablonów zmiennych

The type jest używany w skryptach w celu ułatwienia obsługi błędów w C++ 23. Głównym celem jest opracowanie ogólnej funkcji zwanej które mogą przesyłać dane wyjściowe kilku wartości do innej funkcji. W ten sposób eliminujemy żmudne sprawdzanie błędów, które jest zwykle konieczne podczas pracy z wieloma osobami std::expected wartości jest zmniejszona. jest dość elastyczny, ponieważ może zająć dowolną liczbę parametry za pomocą szablonów variadic. Przed wywołaniem funkcji z zawartością any obiekt, podstawowa logika magic_apply wykorzystuje wyrażenie składane, , aby upewnić się, że wszystko obiekty mają prawidłowe wartości.

Pomysł ten zilustrowano w pierwszym przykładzie skryptu przy użyciu prostych typów, takich jak I . Definiuje A funkcja, która wykonuje podstawowe obliczenia, oraz getA I funkcje, które zwracają typy. Jeśli obie wartości z I getB są zgodne z prawem, możemy zadzwonić używając ; jeśli nie, błąd jest propagowany. Redukując standardowy kod, metoda ta zwiększa czytelność i łatwość konserwacji. Podobny pomysł został przedstawiony w drugim skrypcie, jednak aby podkreślić wszechstronność podejścia, typy i lambda functions są używane.

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

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

Ulepszanie obsługi błędów C++ za pomocą szablonów Variadic

Pojemność znaczne usprawnienie obsługi błędów w skomplikowanych systemach to kolejna kluczowa zaleta zastosowania go w C++. Płynne łączenie wyników wielu akcji asynchronicznych jest niezbędne w sytuacjach, gdy ustępują typy. Oprócz uproszczenia kodu, metoda ta gwarantuje silną obsługę błędów. Bardziej wszechstronne i ogólne funkcje można utworzyć, łącząc dowolną liczbę wartości z variadic templates.

Wszechstronność pozwala na użycie go z funkcjami, które przyjmują różne rodzaje argumentów. Implementację dodatkowo upraszcza się poprzez wykorzystanie , który automatycznie określa typ zwracany przez połączone wywołanie funkcji. Co więcej, tę technikę można rozszerzyć, aby móc zarządzać bardziej złożonymi zadaniami, w tym łączeniem wartości z innymi rodzajami błędów lub zmieniając wartości przed wysłaniem ich do funkcji. Ze względu na możliwości adaptacji wzór może być używany do szerokiego zakresu zadań, od prostych obliczeń po złożone operacje.

W C++23 zaimplementowanie ogólnej funkcji do obsługi wielu wartości std::expected znacznie poprawia czytelność kodu i znacznie upraszcza obsługę błędów. Funkcja magic_apply redukuje szablonowy kod i zwiększa łatwość konserwacji, używając szablonów variadic, aby upewnić się, że wszystkie przewidywane wartości są poprawne przed przetworzeniem. Ta metoda oferuje elastyczne rozwiązanie, które można zastosować w różnych sytuacjach i zapewnia współczesnemu programowaniu w C++ czystszy i skuteczniejszy sposób radzenia sobie z awariami.