Return error code as double

Question

I wonder if I can return error code as double in the following way in C:

double getValue()
{
    double ret = 0;

    if (error1)
    {
        return -1;
    }
    if (error2)
    {
        return -2;
    }
    return ret = ....;
}

int main(void)
{
    double val = getValue();

    if (-1 == val)
    {
        printf("getValue: error1\n")
        return -1;
    }
    else if (-2 == val)
    {
        printf("getValue: error2\n");
        return -2;
    }

    ......
    return 0;
}

so when the return value is >= 0 then it is correct value which can be used for calculations. When value is less than zero error occurred. Will I get the floating-point-comparison problem when I compare return value with -1 or -2 ?

Answer 1

Flag values are a bad idea. Flag values that are floating point are doubly so, even if double precision.

If you are using IEEE double precision floating point values, the values -1 and -2 are exactly representable as doubles, and comparison is well defined. No "magic error" will slip in if you merely copy the double around or only read the value. In fact, on a system with conventional 2s complement 32 bit ints, every int can be represented exactly as a IEEE double precision floating point value.

Now, transformations you think wouldn't matter like x /3. * 3. will ruin the identity, so the code is very fragile: fragile both because flag values are fragile, and because floating point equivalence is often fragile in practice.

In C++, there are a myriad of ways to do this that are less fragile.

enum error_code {a,b,c};
boost::variant<double, error_code> getValue();

is a tagged union that can hold either a double or an error_code. There is a std::expected proposal you can look at which is a tagged union with a "bias" towards the first value being the only valid one (sort of a cross between std::experimental::optional and boost::variant).

Both of these result in the value being returned in a type-safe way, where an error is a different type of value than the non-error return type.

Alternative solutions include returning the error code separately (as the return value, or taking a pointer-to-error-code as a parameter (what I call ICU style)). The double could be set to some innocuous value in that case (say, NaN) rather than left uninitialized.

double getValue( error_code* e );

or

error_code getValue( double* out );

where enum error_code { a = -1, b = -2 } is an enumeration of the error codes.

Answer 2

@LightnessRacesinOrbit beat me to it, but having typed it I post it anyway.

You can do it by taking the value to be set as a pointer argument, and returning a status. That way, no values of *ret are barred.

int getValue(double *ret)
{
    *ret = ...;

    if (error1)
        return -1;
    if (error2)
        return -2;

    return 0;
}

Then the calling code can be such as

double myval;
int err;
if ((err = getValue(&myval)) == 0)
    printf ("getValue() returned %f\n", myval);
else
    printf ("getValue() returned error %d\n", err);

Answer 3

Yes, you could get floating-point errors.

So consider using exceptions instead, or perhaps return an int error code and populate a double "out parameter" on success:

int getValue(double& ret)
{
    if (error1)
        return -1;
    if (error2)
        return -2;

    ret = ....;
    return 0;
}

Answer 4

Doing that is not necessary and makes error handling difficult, you should create an enum where you can add or remove error codes as needed, and also you don't really need to remeber what -1 is or what does -2 mean, just give each error a descriptive name, and do this

enum ErrorCodes {NoError, Error1, Error2, ... , ErrorN};
enum ErrorCodes getValue(double *value)
 {
    if (error1)
        return Error1;
    if (error2)
        return Error2;
    .
    .
    .
    if (errorN)
        return ErrorN;
    *value = resultOfCalculation;

    return NoError;
 }

then

enum ErrorCode code;
double         value;

code = getValue(&value);
switch (code)
 {
    case NoError:
        /* use value here */
        break;
    case Error1:
        /* handle error 1 */
        break;
    /* and so on */
 }

I think this is a lot better and elegant, because you can apply it anytime you want to have robust error checking, no matter what type the target value is, this would work exactly the same for a struct or a double or an int array.