来自 API 的错误代码......处理的好习惯是什么

Question

I am writing a host application using a proprietary API. This API returns error codes when something wrong happened. I need your advise(s) about the best way to push up the error codes and manage them in my host application: Here an short example:

CCas.cpp

CMD_STATUS CCas::shutdown() const
{
        /* CMD_STATUS_OK is an API return code */
    uint8_t statusByte = CMD_STATUS_OK;

    /* Shutdown the CAS system */
    if (CMD_STATUS_OK != (statusByte = CAS_Master_ShutDown()))
        return statusByte;

    /* Set nReset to HIGH */
    ...
        ...

    /* Done the system is OFF */
    return statusByte;
}

main.cpp

int main(char *argc, char **argv)
{
  CMD_STATUS retByte = CMD_STATUS_OK;
  CCas vmx;

  if(retByte != vmx.shutdown())
  /* Something wrong happened */
  return retByte;

  return 0
}

In my example, inside the method shutdown when an error is raised I push up to the main the error inside the statusByte variable and inside the main I catch the error and stop the program.

Do I use it in the right way or there is another way to do. Do I need to create my own error codes in the main.

Please could you advise.

Thanks

Answer 1

There is no definite answer here, and there is no single approach that is the ultimate golden approach to take.
Whatever you do, I would say - keep it consistent.
If you are writing C++ code, you should probably consider using exceptions instead of error codes.
Exceptions help writing your host code in a carefree way and help breaking error handling logic from the main code:

try {
    apiCall();
    anotherApiCall();
    yetAnotherApiCall();
} catch (someKindOfError){
    // Handle error here
} catch (anotherKindOfError){
    // Handle other errors here
} catch (baseError){
    // A more generic error handling here
} catch (...){
    // Just make sure you don't catch what you can't handle and leave higher layers handle it
}

Another approach would be to use error codes, the code is ravaged with if this then that but it's a valid approach non the less.
In this case, I would form a constant that says success (like the posix 0) and then something like:

ErrorType retVal = someApiCall();
if (retVal != ErrorCodeSuccess){
    // either handle generic error or try to find out if it's a specific error, etc.
    if (retVal == ErrorCodeCatIsHungry){
        // Handle error here and probably bail out by calling 'return retVal;'
    }
}

Some people use the approach of returning a failed code ( void functions returning booleans, functions that return objects return null or a static flag object to denote an error) and then call a more detailed error function on request: getLastErrorOfMyLovelyApi() .
Not my personal taste, but sometimes useful in C APIs where the error can be a complex set of information.
It all comes down to who your audience is, what tools you have for them (C++ has exceptions, C does not), and your personal taste.
If you ask me, exceptions (even just the standard ones from stdexcept ) is the way to go in your case.