Question

I am working on an embedded project I am trying to remove a virtual number class that has + / – * implemented. removing this class saves a lot of code space so I have replaced + with the following function,

if (BASE(h)->type() == FLOAT && BASE(v)->type() == FLOAT)
{
    res = FLOAT(h)->floatValue() + FLOAT(v)->floatValue();
}
else if (BASE(h)->type() == INTEGER && BASE(v)->type() == INTEGER)
{
    res = INTEGER(h)->intValue() + INTEGER(v)->intValue();
}
else if (BASE(h)->type() == INTEGER && BASE(v)->type() == FLOAT)
{
    res = INTEGER(h)->floatValue() + FLOAT(v)->floatValue();
}
else 
{
    res = FLOAT(h)->floatValue() + INTEGER(v)->floatValue();
}

Is there a less uglier way to achieve this? cause I have to use the same scheme for other ops and comparison?

Answer 1

#define GETFLOAT(arg) (BASE(arg)->type() == INTEGER ? INTEGER(arg)->floatValue() : FLOAT(arg)->floatValue())

switch(BASE(h)->type()) {
    case INTEGER:
        if (BASE(v)->type() == INTEGER) {
            res = INTEGER(h)->intValue() + INTEGER(v)->intValue();
            break;
        }
    case FLOAT:
        res = GETFLOAT(h) + GETFLOAT(v);
}

This actually branches on the type of h twice, but only in the case that (you say in a comment elsewhere) is expensive anyway, the floating-point op. You could avoid that with a goto, but I’m not going to have that argument again. Something like:

switch(BASE(h)->type()) {
    case INTEGER:
        if (BASE(v)->type() == INTEGER) {
            res = INTEGER(h)->intValue() + INTEGER(v)->intValue();
            goto finished; // or better: return res;
        }
        hvalue = INTEGER(h)->floatValue()
        break;
    case FLOAT:
        hvalue = FLOAT(h)->floatValue();
}
res = hvalue + GETFLOAT(v);
finished:

As with Howard’s answer, if BASE() or type() is expensive then you could calculate the answer for each argument once, even though it’s used twice.