c++ boost tribool ternary operator wrong value

Question

Boost 1.55, MSVC express 2012. Wrong expression evaluation with tribool. It works correct only when I specify tribool(false) explicitly.

Moral of the story: compiler chooses TYPES based on VALUES.

auto a = 0? indeterminate : false; // type function pointer
auto b = 0? indeterminate : true; // type bool

Output:

indet : 1? indeterminate : false
indet : 0? indeterminate : false
true : 1? indeterminate : true
true : 0? indeterminate : true
indet : 1? indeterminate : tribool(false)
false : 0? indeterminate : tribool(false)
indet : 1? indeterminate : tribool(true)
true : 0? indeterminate : tribool(true)

Source code:

#include <iostream>
#include <boost/logic/tribool.hpp>

using namespace boost;

void test_tribool( const tribool& v, const char* name )
{
    const char* s;
    if ( v )
        s = "true";
    else if ( !v )
        s = "false";
    else
        s = "indet";
    std::cout << s << "\t: " << name << std::endl;
}

#define TEST_TRIBOOL( ... ) test_tribool( (__VA_ARGS__), #__VA_ARGS__ );

int main(int argc, char** argv)
{
    TEST_TRIBOOL( 1? indeterminate : false );
    TEST_TRIBOOL( 0? indeterminate : false );

    // warning C4305: ':' : truncation from 'bool (__cdecl *)(boost::logic::tribool,boost::logic::detail::indeterminate_t)' to 'bool'
    TEST_TRIBOOL( 1? indeterminate : true );

    // warning C4305: ':' : truncation from 'bool (__cdecl *)(boost::logic::tribool,boost::logic::detail::indeterminate_t)' to 'bool'
    TEST_TRIBOOL( 0? indeterminate : true );


    TEST_TRIBOOL( 1? indeterminate : tribool(false) );
    TEST_TRIBOOL( 0? indeterminate : tribool(false) );
    TEST_TRIBOOL( 1? indeterminate : tribool(true) );
    TEST_TRIBOOL( 0? indeterminate : tribool(true) );

    return 0;
}

What *exactly* happens what you did not expect? Do you need that much code to demonstrate it? And why does your macro use `...` if it only works with a single argument anyway? — Christopher Creutzig, Jan 11 '14 at 11:40
You do realize that in `a ? b : c`, `b` and `c` must have the same type and the compiler did tell you which way it resolved the conflict in your code, yes? — Christopher Creutzig, Jan 11 '14 at 11:44
I can make code work, but I'm just curious why (2) is what it is. How that possible? I use ... in macro because it's universal. — toby_toby_toby, Jan 11 '14 at 12:09

mockinterface · Accepted Answer · 2014-01-11T12:18:41.740

These are different types and MSVC should be rightfully giving you a warning about this; from their own documentation:

 The following rules apply to the second and third expressions:

     If both expressions are of the same type, the result is of that type.

     If both expressions are of arithmetic or enumeration types, 
     the usual arithmetic conversions (covered in Arithmetic Conversions)
     are performed to convert them to a common type.

     If both expressions are of pointer types or if one is a pointer type 
     and the other is a constant expression that evaluates to 0,
     pointer conversions are performed to convert them to a common type.

     If both expressions are of reference types, reference conversions 
     are performed to convert them to a common type.

     If both expressions are of type void, the common type is type void.

     If both expressions are of a given class type, the common type is 
     that class type.

 Any combinations of second and third operands not in the preceding
 list are illegal. The type of the result is the common type, and it is
 an l-value if both the second and third operands are of the same type
 and both are l-values.

Because your ternary operator doesn't return the same type, for the combination of bool and indeterminate, the result undergoes a conversion which probably matches the

     If both expressions are of pointer types or if one is a pointer type 
     and the other is a constant expression that evaluates to 0,
     pointer conversions are performed to convert them to a common type.

Which matches the,

typedef bool (*indeterminate_keyword_t)(tribool, detail::indeterminate_t);

definition in tribool.hpp. It is that function pointer which is being "evaluated" instead of the false value.

So, you must have the ? operator return the same type. Change your macros to look like this:

TEST_TRIBOOL( 1 ? tribool(indeterminate) : tribool(false));

or alternatively,

const tribool t_indet(indeterminate);
const tribool t_false(false);
const tribool t_true(true);

TEST_TRIBOOL( 1 ? t_indet : t_false );
TEST_TRIBOOL( 0 ? t_indet : t_false );
...

I know HOW to fix, but WHY it should be fixed in the case of (0? indeterminate : false) == indet. What exactly happening? — toby_toby_toby, Jan 11 '14 at 12:04
I think that bool casted to function pointer==0 is an answer, thanks!! — toby_toby_toby, Jan 11 '14 at 12:16
For what it's worth, this pattern is called the safe bool idiom (which isn't really required if your compiler supports c++ explicit conversion operators — sehe, Jan 12 '14 at 00:01

c++ boost tribool ternary operator wrong value

1 Answers1