Elegant ways to return status code and pointer from a C function

Question

I was currently reading this question which shows problems about using void ** as a parameter to return a pointer from a function.

My code mostly has status codes as return values, and now I am looking for alternative ways to return these pointers AND a status code. So I currently see a couple of options, but none of them really make me happy. Probably I am overthinking a little.

// Output status through return value and the pointer through parameter 
// - seems to be problematic because it requires casting to void **, which is invalid
int myfunc(void **output);

// Output status through return value, pointer through struct 
// - seems to add unnecessary complexity to the interface
struct some_output { void *value };
int myfunc(struct some_output *output);

// Output pointer through return value, status through parameter 
// - breaks consistency with other interfaces which always return the status code
void *myfunc(int *status);

Now I am wondering whether there are other, alternative, elegant ways to return pointers and status codes from a function which I did not think about that don't have "drawbacks"?

Answer 1

With 'C', when functions are limited to returning a single value, there is no one perfect method. There are few patterns that are commonly being used, and are followed by various available API. Consider sticking with one of the proven, less then perfect, methods:

• int status = function(struct Result *output, input) ;

  • Work for simple cases, with small number of success/failures.
  • Common to use 0 and positive for success, negative for errors.

• int result = function(*output, input) ; with extended error code.

  • Used with used for many Linux system calls/APIs, extra error detail in 'errno'.
  • Common to use 0 and positive for success, negative for errors.
  • Challenge with MT systems, because of single error code. In many cases, error information actually available as functions that wraps thread local result.

• bool success = function(*output, input) ; with callback error

  • Making it easy to pass success/failure.
  • Error information passed to user defined error callback.
  • Implemented in many GUI callbacks (e.g, X11), already using callbacks.

• struct result *res = function(input, struct errro **error)

  • Used in Glib or other libraries which handle complex data types (not just arrays)
  • Usually, each structure will have corresponding free* functions.
  • Error address (if passed) will capture error data.
  • Error will result in res = NULL, and error being set.
  • Closer in spirit to try/catch.

When introducing generic calls, the common theme that I observed is usually to have the output and the error objects at the same location in the argument list (not necessary togethe!). In many cases the output is placed as the first, and the error/exception is placed at the end.

Worth looking into Error handling in C code

Answer 2

I agree with @Mat use a:

typedef Gret struct generic_ret;
struct generic_ret {
    int Status;
    union {
     void *p;
     DialPlan *d;
    };
}
...
Phone = GetPhone(...);
if (Phone.Status == 0) {
     Dial(Phone.d);
     ...
}

Keep that up and you will end up programming in Go... The other classic approach to status + pointer is to reserve more pointer values than 0:

extern DialPlan *DP_NoService, *DP_BadNumber, *DP_Broke, ...;
extern bool IsDialError(DialPlan *p);
....
static DialPlan *DP_FirstError = 0,
                *DP_NoService = (void *)1,
                *DP_BadNumber = (void *)2,
                *DP_LastError = (void *)10;
bool IsDialError(DialPlan *p) {
     return (p > DP_FirstError && p < DP_LastError);
}

Or, if you prefer the look of safety:

static DialPlan Errors[10];
static DialPlan *DP_NoService = Errors + 0,
                *DP_BadNumber = Errors + 1,
                ...
                *DP_LastError = Errors + 9;