1. [Firebird]: I/O error during "WriteFile" operation for file "D:\DATABASE\RAM\IBP_TEST_FB30_D3_2.GDB"
Error while trying to write to file
Неверный дескриптор.
2. [LCPI.IBProvider.5]: Ошибка подтверждения транзакции. Транзакция будет отменена.
3. [Firebird]: internal Firebird consistency check (can't continue after bugcheck)
4. [LCPI.IBProvider.5]: Ошибка отката транзакции.

По неизвестной причине зафиксировать транзакцию не удалось. Данная транзакция была отменена.
COM Error Code: XACT_E_COMMITFAILED

std::vector<std::string> child() {...}

std::vector<std::string> parent() {
  ...
  auto r = std::move(child()); // (1)
  ...
  return std::move(r); // (2)
}

void foo(int *error, char a, float b, short c)
{
   if (*error) return;
   // do some stuff
   if (/* condition */)
   {
      *error = ERROR_IO_FAIL;
      return;
   }
   // do some stuff
}

void bar(int *error, char a)
{
   if (*error) return;
   // do some stuff
   foo(error, a, 2.7f, 123); if (*error) return;
   if (/* condition */)
   {
      *error = ERROR_IO_FAIL;
      return;
   }
   foo(error, a, 3.14f, 456); if (*error) return;
   // do some stuff
}

void main()
{
   int error;
   // do some stuff
   bar(&error, 'X'); if (*error) return;
   bar(&error, 'Y'); if (*error) return;
   // do some stuff
}

template<typename Res> 
using expected = std::variant<Res, std::exception_ptr>;

template<typename Functor>
struct action { Functor f; }

template<typename Functor>
auto map(Functor&& f)
{
    return action{std::forward<Functor>(f)};
}

template<typename Res> 
auto operator | (expected<Res> const& ex, action const& a)
{
    using Ret = decltype(a.f(std::declval<Res>()));
    return std::holds_alternative<Res>(ex)
        ? expected<Ret>{ a.f(std::get<0>(ex)) }
        : expected<Ret>{ std::get<1>(ex) };
}

// использование
const bool isEmptyLogin = getUserByHttp()
    | map(getLoginByUser)
    | map([](auto const& v) { return v.empty(); })

SP>template<typename Res> 
SP>using expected = std::variant<Res, std::exception_ptr>;
SP>

expected<int, int> do_something() {...}

S>expected<int, int> do_something() {...}
S>

template<typename T>
struct error
{
    T val;
}

template<typename Res, typename Err = std::exception_ptr> expected = std::variant<Res, error<Err>>;

template<typename Val, typename Err>
struct expected_helper
{
    union
    {
    Val v;
    Err e;
    }
    bool isError;
}

Во-первых, как уже сказано, и в отладочном режиме скорость может быть важна, и критически важна.

err.Set( ErrorBufferNotEnough )

err.Set( FileNotFound, "File '%s' not found", file_name )

err = f();
if( err.IsError() ) {
  return err;
}

err = f();
if( err.IsError() ) {
  return CError( ErrorFatal );
}

err = f();
if( err.IsError() ) {
  return CError( ErrorFatal, err );
}

err = f();
if( err.HasMsg() ) {
  return err;
} else if( err.IsError() ) {
  return CError( ErrorFatal, err );
}

CError result;
if( check username field ) {
   CError err( ErrorInvalidConfig, "Invalid value '%s'", val );
   err[ "field" ] = "username";
   result += err;
}
if( check first_name field ) {
   CError err( ErrorInvalidConfig, "Invalid value '%s'", val );
   err[ "field" ] = "first_name";
   result += err;
}
return result;

CError = f1();

CError err;
auto r = f1( err );

auto r = f1();
if( r == InvalidValue ) {
   CError err = CError::GetLastError();
}