Sử dụng std::apply trên std::expected trong C++23

Giảm độ phức tạp trong xử lý lỗi C++ với `std::expected}

Tập lệnh C++23 sử dụng các mẫu biến đổi

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

Kết hợp các giá trị {std::expected} khác nhau cho kết quả C++23

Tập lệnh C++23 sử dụng hàm 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;
}

Câu hỏi thường gặp về Mẫu đa dạng và std::expected

1. Là gì std::expected?
2. Đây là loại mẫu C++ có thể chứa lỗi hoặc giá trị hợp lệ và được sử dụng để quản lý lỗi.
3. Làm thế nào magic_apply công việc?
4. Nó loại bỏ sự cần thiết phải kiểm tra lỗi lặp đi lặp lại bằng cách kết hợp các kết quả của nhiều std::expected các giá trị và chuyển chúng tới một hàm.
5. Mẫu variadic là gì?
6. Các mẫu biến mang lại nhiều sự tự do trong thiết kế hàm bằng cách cho phép các hàm chấp nhận số lượng tham số tùy ý.
7. Tại sao sử dụng decltype TRONG magic_apply?
8. Việc sử dụng các giá trị của std::expected đối tượng để tự động xác định kiểu trả về của hàm được gọi.
9. Là magic_apply có khả năng xử lý các loại lỗi khác nhau?
10. Có, nó có thể được thực hiện để hoạt động với std::expected các giá trị có nhiều loại lỗi khác nhau với một vài điều chỉnh.
11. Việc sử dụng có lợi ích gì std::expected lời đề nghị?
12. Khi xử lý lỗi, nó đưa ra cách tiếp cận rõ ràng và rõ ràng hơn so với các kỹ thuật thông thường hơn như ngoại lệ hoặc mã trả về.
13. Là std::unexpected một phần của std::expected?
14. Ngoài ra std::expected, std::unexpected trên thực tế, nó đại diện cho một giá trị không chính xác.
15. Các hành động không đồng bộ có thể được sử dụng với magic_apply?
16. Nó thực sự có khả năng thích ứng để xử lý std::expected các giá trị được trả về bởi các hoạt động không đồng bộ.
17. Biểu thức gấp là gì?
18. Ở đây, tính năng trong C++ được gọi là biểu thức gấp được sử dụng để kiểm tra xem tất cả std::expected các đối tượng chứa các giá trị hợp lệ một cách đơn giản.

Kết thúc:

Trong C++23, việc triển khai một hàm chung để xử lý nhiều giá trị std::expected sẽ cải thiện đáng kể khả năng đọc mã và đơn giản hóa đáng kể việc xử lý lỗi. Hàm magic_apply làm giảm mã soạn sẵn và tăng cường khả năng bảo trì bằng cách sử dụng các mẫu biến đổi để đảm bảo tất cả các giá trị dự kiến ​​đều chính xác trước khi xử lý. Phương pháp này cung cấp một giải pháp linh hoạt có thể áp dụng cho các tình huống khác nhau và mang lại cho chương trình C++ hiện đại một cách rõ ràng hơn, hiệu quả hơn để xử lý lỗi.