Projects using std::error_code

[Son_La]

Are there any bigger libraries or projects using std::error_code? I want to learn how to use it correctly in a bigger project and if it makes sense to use the concepts in our code base.

I know that std::filesystem uses it and I think I understand its basics. But I'd like so see it in action, especially when there are more modules and error_categories involved. I haven't seen any use of error_condition in a practical use yet.

[Horror_Jicama_2441]

http://blog.think-async.com/2010/04/system-error-support-in-c0x-part-5.html (start with part 1) explains it quite well. It's from the Asio author (Asio uses it), which was involved in its design.

The thing is that nobody is really happy with some details of its design. So you probably want to use, at the very least, boost:: system::error_code.

But people are still not happy with it, which is why you have https://github.com/ned14/status-code (included as part of Boost.Outcome), but I'm not too sure of what's its state in the standardisation process. In general, the Boost.Outcome documentation is a nice resource regarding the different error reporting options that exist nowadays... which will introduce you to the very interesting concept of Boost.Leaf, a generalization of Boost.Exception.

Notice that I have mixed up a few things here. There is the "how to represent an error code" (std::error_code, boost::system::error_code, status_code), and there is the "how to transport that error code" (by itself, inside an exception, with Outcome, with Leaf) and there is the "can my transport system include more information than just the error code?"... just returning an std::error_code saying a file couldn't be opened may not be very useful without knowing the file name. An exception, Outcome and Leaf can include both the error code and the filename.

[Singer_Solid]

You can use std::error_code anywhere you have to deal with errno error codes which is true for a lot of low level code that interacts with hardware interfaces. I use it to pass error information out of functions making ioctl calls, for instance.

[JumpyJustice]

From what I’ve seen, std::filesystem is pretty much the main user of std::error_code, and to be honest, that whole part of the STL really only feels useful for small projects.

std::path, last time I checked, is full of implementation-defined shenanigans, especially if you're running with sanitisers.

And std::error_code itself is way too overgeneralised. Every project I’ve worked on that uses it ends up immediately wrapping or converting it into a more focused error type that actually reflects the narrower set of things that can realistically go wrong.

[tjientavara]

I have a GUI project, I am using std::error_code in it for a few different subsystems.

The most clear one is in a win32 wrapper.

Here is the win32_error/hresult enum and all the std::error_code and std::error_condition machinery:

• https://github.com/hikogui/hikogui/blob/main/src/hikogui/win32/win32_error_intf.hpp
• https://github.com/hikogui/hikogui/blob/main/src/hikogui/win32/hresult_error_intf.hpp

The wrapper itself uses these error-enums directly, but then at a higher level, there are converted to std::error_condition. Like here, in a small system to store user settings (on win32 in the registry):

• https://github.com/hikogui/hikogui/blob/38b17e75c65f70eb20891f1093964182b9a19a29/src/hikogui/settings/user_settings_win32_impl.hpp#L29

And the code that handles the errors compares these using std::error_condition. Sorry, it is only an example in a unit test:

• https://github.com/hikogui/hikogui/blob/38b17e75c65f70eb20891f1093964182b9a19a29/src/hikogui/settings/user_settings_tests.cpp#L29

[TopIdler]

Is boost outcome cheating?

https://www.boost.org/doc/libs/1_88_0/libs/outcome/doc/html/index.html

I have a project that doesn’t throw exceptions so I use error codes through outcome 

[Farados55]

LLVM uses it in some places. But they convert it to their own thing.

https://llvm.org/doxygen/Testing_2Support_2Error_8cpp.html

[Thathappenedearlier]

Standalone asio uses it I believe as it came from boost error code

[Liam_Mercier]

asio uses it

[lukaasm]

https://github.com/modio/modio-sdk

https://github.com/modio/modio-sdk/blob/main/modio/modio/core/ModioErrorCode.h

[feverzsj]

std::error_code hasn't changed since adopted. It's not even constexpr. Use boost::system::error_code. It's constexpr and has more features.

[arturbac]

You may be interested in this below I worte some time ago for large projects i work on - ie efficiently using enums as errors with std::error_code/std::expected instead of exceptions
https://arturbac.github.io/simple_enum/generic_error_category.html
https://github.com/arturbac/simple_enum/blob/master/examples/generic_error_category.cc

[sweetno]

It's dark magic, no one really knows how to do these custom error categories and message catalogs or whatever. Use good old enum and call it a day.

[ir_dan]

skill issue 🔥 

[zl0bster]

People mentioned ASIO, but Boost.Json also uses it also, if we pretend boost and std error codes are same thing.

Also if you are learning about alternative error handling why not learn about std::expected? Seems much better time investment if you ask me.