Đây có thể là một câu hỏi ngớ ngẩn, nhưng tôi đang tìm cách ngắn gọn để kiểm tra kết quả trả về của một hàm và nếu nó không đáp ứng một điều kiện nào đó thì trả về giá trị đó (tức là truyền nó đi).

Đây có thể là một câu hỏi ngu ngốc, nhưng tôi đang cố gắng tìm hiểu xem có cách nào ngắn gọn để kiểm tra xem hàm trả về gì không và nếu nó không thỏa mãn điều kiện, hãy trả về giá trị đó (tức là chuyển nó đi).

Để trả lời một câu hỏi có thể có ngay bây giờ, vâng, những gì tôi đang tìm kiếm tương tự như những gì ngoại lệ cung cấp. Tuy nhiên, với tư cách là một nhà phát triển nhúng, chi phí liên quan đến ngoại lệ (thật không may) là một chi phí quá cao để trả.

Bây giờ để trả lời một câu hỏi có thể xảy ra, vâng, điều tôi đang tìm kiếm là thứ gì đó tương tự với những gì ngoại lệ cung cấp. Tuy nhiên, với tư cách là một nhà phát triển nhúng, chi phí liên quan đến các trường hợp ngoại lệ (đáng buồn là) quá cao để phải trả.

Ví dụ,

Ví dụ,

Trạng thái lớp enum
{
    ĐƯỢC RỒI,
    LỖI1,
    LỖI2,
    LỖI3
};

Trạng thái foo1();
Trạng thái foo2();
Trạng thái foo3();

Thanh trạng thái()
{
    Kết quả trạng thái;

    kết quả = foo1();
    nếu (kết quả != Trạng thái::OKAY) trả về kết quả;
   
    kết quả = foo2();
    nếu (kết quả != Trạng thái::OKAY) trả về kết quả;

    kết quả = foo3();
    nếu (kết quả != Trạng thái::OKAY) trả về kết quả;

    trả về Trạng thái::ĐƯỢC;
}

Nếu tôi chỉ sử dụng bool làm giá trị trả về, cách viết tắt sẽ là như sau:

Nếu tôi chỉ sử dụng boolean làm giá trị trả về thì cách viết tắt là viết đoạn mã sau:

thanh bool()
{
    nếu (!foo1()) trả về false;
    nếu (!foo2()) trả về false;
    nếu (!foo3()) trả về false;

    trả về giá trị đúng;
}

Một mệnh đề if có tác dụng phụ như thế này được coi là mã lỗi, nhưng với tôi, điều này có vẻ dễ đọc và súc tích hơn so với các phép thử và gán biến cục bộ.

Các mệnh đề IF có tác dụng phụ như thế này được coi là có mùi mã, nhưng theo tôi, nó dễ đọc và ngắn gọn hơn so với các bài kiểm tra và phép gán biến cục bộ.

Có cách viết tắt nào để đạt được khả năng đọc tương tự như ví dụ thứ hai nhưng vẫn mang lại hiệu quả như ví dụ thứ nhất không?

Có cách nào nhanh chóng để đạt được khả năng đọc tương tự như ví dụ thứ hai nhưng có hiệu quả tương tự như ví dụ đầu tiên không?

Một cách để thực hiện là sử dụng macro:

Một cách là sử dụng macro:

Trạng thái lớp enum
{
    ĐƯỢC RỒI,
    LỖI1,
    LỖI2,
    LỖI3
};

#define KIỂM TRA_TRẠNG THÁI(gọi_nơi)\
    LÀM {\
      Kết quả trạng thái = call_site;\
      nếu (kết quả != Trạng thái::OKAY) trả về kết quả;\
    } trong khi(0)

Trạng thái foo1();
Trạng thái foo2();
Trạng thái foo3();

Thanh trạng thái()
{
    KIỂM TRA_TRẠNG THÁI(foo1());
   
    KIỂM TRA_TRẠNG THÁI(foo2());
    
    KIỂM TRA_TRẠNG THÁI(foo3());

    trả về Trạng thái::ĐƯỢC;
}

Nếu bạn bối rối bởi làm ... trong khi(0), hãy kiểm tra điều này: do { ... } while (0) — nó có tác dụng gì?

Nếu bạn đang bối rối về DO... While(0), hãy kiểm tra điều này: Do{...}while(0) - nó dùng để làm gì?

Vì bạn đang sử dụng C++17, bạn có thể viết thanh() chức năng như thế này, theo tôi thì cũng không tệ lắm:

Vì bạn đang sử dụng C++17, bạn có thể viết hàm bar() như thế này, điều này không tệ, IMO:

Thanh trạng thái() {
    nếu (kết quả tự động = foo1(); kết quả != Trạng thái::OKAY) trả về kết quả;
    nếu (kết quả tự động = foo2(); kết quả != Trạng thái::OKAY) trả về kết quả;
    nếu (kết quả tự động = foo3(); kết quả != Trạng thái::OKAY) trả về kết quả;
    trả về Trạng thái::ĐƯỢC;
}

Hoặc, lambda cũng có thể hữu ích. Mặc dù tôi thấy nó ít hấp dẫn hơn trong tình huống cụ thể này:

Ngoài ra, Lambda cũng có thể có ích. Tuy nhiên, trong trường hợp cụ thể này, tôi thấy nó kém hấp dẫn hơn:

Thanh trạng thái() {
    kết quả tự động = Trạng thái::ĐƯỢC;
    tự động kiểm tra const = [&result](tự động foo) -> bool
    { trả về (kết quả = foo()) != Trạng thái::OKAY; };

    nếu (kiểm tra(foo1)) trả về kết quả;
    nếu (kiểm tra(foo2)) trả về kết quả;
    nếu (kiểm tra(foo3)) trả về kết quả;
    trả về kết quả;
}

Có lẽ việc viết functor của riêng bạn sẽ hiệu quả hơn:

Có lẽ việc viết chức năng của riêng bạn hoạt động tốt hơn:

Thanh trạng thái() {
    cấu trúc {
        Kết quả trạng thái;
        bool toán tử()(Trạng thái (&foo)())
        { trả về (kết quả = foo()) != Trạng thái::OKAY; };
    } kiểm tra{};

    nếu (kiểm tra(foo1)) trả về kết quả kiểm tra;
    nếu (kiểm tra(foo2)) trả về kết quả kiểm tra;
    nếu (kiểm tra(foo3)) trả về kết quả kiểm tra;
    trả về kiểm tra.kết quả;
}

Một cách khác là tận dụng khởi tạo tổng hợp, nhưng cách này có phần phức tạp hơn một chút.

Một cách tiếp cận khác là sử dụng khởi tạo tổng hợp, nhưng cách này hơi vượt trội về mặt thủ thuật.

Thanh trạng thái() {
    cấu trúc chuyển đổi {
        Kết quả trạng thái;
        toán tử rõ ràng bool() const
        { trả về kết quả != Trạng thái::OKAY; }
    } kiểm tra{};

    nếu ((kiểm tra = chuyển đổi {foo1()})) trả về kết quả kiểm tra;
    nếu ((kiểm tra = chuyển đổi {foo2()})) trả về kết quả kiểm tra;
    nếu ((kiểm tra = chuyển đổi {foo3()})) trả về kết quả kiểm tra;
    trả về kiểm tra.kết quả;
}

Ví dụ trực tiếp

Ví dụ trực tiếp

Dựa trên bình luận của @NathanOliver về câu hỏi của tôi, tôi đã viết ra giải pháp khả thi sau đây.

Dựa trên nhận xét của @NathanOliver về câu hỏi của tôi, tôi đã viết giải pháp khả thi sau đây.

#include 

Trạng thái lớp enum
{
    ĐƯỢC RỒI,
    QUÁ NHỎ,
    QUÁ LỚN
};

bool toán tử!(Trạng thái s)
{
    trả về s != Trạng thái::OKAY;
}

std::ostream& operator<<(std::ostream& os, Trạng thái s)
{
    công tắc
    {
    trường hợp Trạng thái::OKAY:
        os << "ĐƯỢC";
        phá vỡ;
    trường hợp Trạng thái::QUÁ NHỎ:
        os << "QUÁ NHỎ";
        phá vỡ;
    trường hợp Trạng thái::QUÁ LỚN:
        os << "QUÁ LỚN";
        phá vỡ;
    }
    
    trả về hệ điều hành;
}

Thanh trạng thái (int a)
{
    nếu (a < 5) trả về Trạng thái::QUÁ_NHỎ;
    nếu (a > 10) trả về Trạng thái::QUÁ_LỚN;
    nếu không thì trả về {};
}

Trạng thái foo(int a)
{
    nếu (tự động r = bar(a); !r) trả về r;
    nếu (tự động r = bar(a + 1); !r) trả về r;
    nếu (tự động r = bar(a - 1); !r) trả về r;
        
    trở lại {};
}

void test(int a)
{
    kết quả tự động = foo(a);
    std::cout << "foo(" << a << ") -> " << kết quả << std::endl;
}

int chính()
{
    kiểm tra(8);
    kiểm tra(5);
    kiểm tra(10);
    
    trả về 0;
}

Tôi đã đơn giản hóa việc kiểm tra có điều kiện của enum bằng cách nạp chồng toán tử !.

Các phương pháp đơn giản hóa việc kiểm tra có điều kiện của bảng liệt kê! nhà điều hành.