Thread: bug in ternary operator ?:

Given the following code snippet:

Code:

    unsigned long long x;

    x = (0 ? (double) 0 : 0xf1debc9a78563412ULL);

On GCC 4.5.0 on a i686 mingw32_NT-5.1 I get the result 0xf1debc9a78563800. It appears the constant value is being converted to a double then back to an unsigned long long. Is this a feature or a bug? If you ask why this is useful I was trying to use it as part of size independent byte swap macro:

Code:

#define _floating_type(type) (((type) 0.25) && ((type) 0.25 - 1))

#define BSWAP(x, type)                                                                \
    (_floating_type (type) && (sizeof (type) == sizeof  (float)) ? bswap_float  (x) : \
    (_floating_type (type) && (sizeof (type) == sizeof (double)) ? bswap_double (x) : \
    (sizeof (type) == sizeof (uint8_t)  ? (x)         :                               \
    (sizeof (type) == sizeof (uint16_t) ? bswap16 (x) :                               \
    (sizeof (type) == sizeof (uint32_t) ? bswap32 (x) :                               \
    (sizeof (type) == sizeof (uint64_t) ? bswap64 (x) : (1/0))))))))

Originally Posted by wiglaf

Given the following code snippet:

Code:

    unsigned long long x;

    x = (0 ? (double) 0 : 0xf1debc9a78563412ULL);

Mostly it's failing because you are trying to assign a double to an int and you can't do that.
Plus your bracketing is wrong.

PLEASE!! I did not ask why the code is wrong. I am asking why the compiler does not interpret it as I would expect. Both conditions of the ?: operator have different types, but although the first condition is not taken the result of the second condition is cast to the type of the first. I would not expect this behavior. Is the behavior given in a standard or is this a compiler bug?
I appreciate your time.

>> PLEASE!! I did not ask why the code is wrong.

I know.

>> I am asking why the compiler does not interpret it as I would expect.

And I'm telling you, man, why it's not.

quzah puts it plainly. The ternary operator is just another way to write if-else, except that you're limited to executing a single expression for either branch.

>> Both conditions of the ?: operator have different types, but although the first condition is not taken the result of the second condition is cast to the type of the first.

Types are irrelevant. The condition of the ternary operator is false, and will always be false, so the expression "(double) 0" is never executed. What gets assigned to x in the other branch may incidentally mean the same thing as that, but it doesn't matter. It's how ternary is defined to work by the standard that matters.

>> I would not expect this behavior. Is the behavior given in a standard or is this a compiler bug?

Again, not a feature or a bug.

>> I appreciate your time.

Yes, you're welcome, please be more respectful in the future. "PLEASE I didn't ask what is wrong" ... yes you did, and people gave you the answer to your actual question.

Both conditions of the ?: operator have different types, but although the first condition is not taken the result of the second condition is cast to the type of the first. I would not expect this behavior. Is the behavior given in a standard or is this a compiler bug?

The former. While the second and third operands have different types, the conditional operator determines a common type and one or both are converted to that type. How is this determined, you ask? A fine question. Answer: by applying the usual arithmetic conversions to both operands (assuming both have arithmetic type, which they do in this example).

What are the usual arithmetic conversions (you may be asking yourself)? They're a set of rules, the start of which I shall quote here:

Originally Posted by C99 6.3.1.8

First, if the corresponding real type of either operand is long double, the other operand is converted, without change of type domain, to a type whose corresponding real type is long double.

Otherwise, if the corresponding real type of either operand is double, the other operand is converted, without change of type domain, to a type whose corresponding real type is double.

Since one is a double, the other (your unsigned long long) is converted to double, then back to unsigned long long by assignment. Thus you should get the same value as you would doing:

Code:

printf("%llx\n", (unsigned long long)(double)0xf1debc9a78563412ULL);

I just tried the following and also received the same result:

Code:

    x = (1 ? 0xF1DEBC9A78563412ULL : (double) 0.0);

So it does appear the compiler is just promoting both types to double.

To be clear I am not asking how to use the ?: operator, I'm asking why my compiler does this:

Code:

if (0) {
    x = (double) 0.0;
} else {
    x = (double) 0xF1DEBC9A78563412ULL;
}

When I expect it to do this

Code:

if (0) {
    x = (double) 0.0;
} else {
    x = 0xF1DEBC9A78563412ULL;
}

The snippet of code was simply the smallest example that showed this.

brewbuck, the right hand side is a conditional expression. It evaluates to one expression or the other. There is nothing quantum mechanical about that. It is either one or the other. So I didn't see any reason why the return type can't be the same as the evaluated expression. After all that would make the ternary operator ?: equivalent to an if/else statement. That is, the following two expressions would be the same:

Code:

double b;
long long int c, x;

x = a ? b : c;

if (a) {
  x = b;
} else {
  x = c;
}

But it is not. The else statement is evaluated as x = (long long int) (double) c in the ternary operator. This can make for some obscure bugs. I did find this behavior documented elsewhere, so I'll work around it...

Thanks laserlight, that is what I was looking for...