is there any exception with error code in stl? - c++

Question

I read several discussion on the use of exception and error code and when each of them is suitable.
I believe in my case exceptions are better, but I have one specific problem:
if I throw a std::runtime_error("this is an error") and then I catch it, I can not find what was the error, I just understand that there was an error.
What I am looking is an exception that I can throw and add an error code to it so later I can check the error code when I catch it, some thing such as this:
enum errorCodes
{
error_1,
error_2,
error_3
}
try
{
throw std::runtime_error(error_1,"can not do the job!");
}
catch (std::runtime_error & err)
{
switch (err.errorCode)
{
case error_1:
// I can not contunue, so re throw it
rethrow err;
case error_2:
// it is not important for me, so I can continue
break;
case error_3:
//Oh, I need to do something before continue
re_init();
break;
default:
rethrow err;
}
I can write such exception, but before doing this, I am wondering if such type of exception exist in STL or BOOST?
Is there any better way of doing this ( I am not interested to throw different type of exception, so catching different type of exception is not a solution from my point of view.

Answer 1

Yes, there's std::system_error. It's derived from std::runtime_error. It's pretty Unix-land-oriented but it does support error codes in general, and I suggest that you use it that way.
The following code demonstrates how to define one's own error category for application specific error codes:
#include <string>
#include <system_error>
#include <typeinfo>
namespace my{
struct Error_code
{
enum Enum
{
error_1 = 101,
error_2 = 102,
error_3 = 103
};
};
class App_error_category
: public std::error_category
{
using Base = std::error_category;
public:
auto name() const noexcept
-> char const*
override
{ return "App error"; }
auto default_error_condition( int const code ) const noexcept
-> std::error_condition
override
{ (void) code; return {}; }
auto equivalent( int const code, std::error_condition const& condition ) const noexcept
-> bool
override
{ (void) code; (void) condition; return false; }
// The intended functionality of this func is pretty unclear.
// It apparently can't do its job (properly) in the general case.
auto equivalent( std::error_code const& code, int const condition ) const noexcept
-> bool
override
{ return Base::equivalent( code, condition ); }
auto message( int const condition ) const
-> std::string
override
{ return "An application error occurred, code = " + std::to_string( condition ); }
constexpr
App_error_category(): Base{} {}
};
auto app_error_category()
-> App_error_category const&
{
static App_error_category the_instance;
return the_instance;
}
class App_error
: public std::system_error
{
using Base = std::system_error;
public:
auto app_error_code() const
-> Error_code::Enum
{ return static_cast<Error_code::Enum>( code().value() ); }
App_error( Error_code::Enum const code )
: Base{ code, app_error_category() }
{}
App_error( Error_code::Enum const code, std::string const& description )
: Base{ code, app_error_category(), description }
{}
};
} // namespace my
void foo()
{
try
{
throw my::App_error( my::Error_code::error_1, "can not do the job!" );
}
catch( my::App_error const& x )
{
switch( x.app_error_code() )
{
case my::Error_code::error_1:
// I can not contunue, so re throw it
throw;
case my::Error_code::error_2:
// it is not important for me, so I can continue
break;
case my::Error_code::error_3:
//Oh, I need to do something before continue
//re_init();
break;
}
}
}
#include <iostream>
#include <stdlib.h> // EXIT_SUCCESS, EXIT_FAILURE
using namespace std;
auto main()
-> int
{
try
{
foo();
return EXIT_SUCCESS;
}
catch( exception const& x )
{
cerr << "!" << x.what() << endl;
}
return EXIT_FAILURE;
}
With both Visual C++ 2015 and MingW g++ 6.4.0 this produces the output
!can not do the job!: An application error occurred, code = 101
In general it's more practical to define specific exception classes than to use error codes. However, for system error codes it's more practical to just pass these codes up with the exception. And for that the complexity shown above can be avoided, since the std::system_category is then eminently suitable.
In short, the complexity here stems from your requirement to not go with the flow, but in a direction somewhat against the current.

Answer 2

Consider using std::system_error out of the box.
Note that using simply throw; without an argument is a far better way of re-throwing your exception (you seem to be using throw err;) since the former will throw the exception by reference rather than by value: the latter can cause object slicing.