How to best convert VARIANT_BOOL to C++ bool?

Question

When using COM boolean values are to be passed as VARIANT_BOOL which is declared in wtypes.h as short. There are also predefined values for true and false:

#define VARIANT_TRUE ((VARIANT_BOOL)-1)
#define VARIANT_FALSE ((VARIANT_BOOL)0)

Which is the best way to convert from VARIANT_BOOL to C++ bool type? Obvious variants are:

1. compare with VARIANT_FALSE

2. simply cast to bool

Other ways can be easily invented.

Which is the best way to do this - most readable, most standart-compliant, least prone to accidential bugs planting and least prone to issues with porting to 64-bit platforms?

Answer 1

Why have an explicit cast?

if (my_bool)
{
    blargh();
}
else
{
   blarglerr();
}

This way, true is true and false is false, as per the C standard. If you need to SET a C++ style bool then do something like:

VARIANT_BOOL vb_bool = VARIANT_FALSE
bool cpp_bool = !!vb_bool

Answer 2

I don't like to have to worry about compatibility between different boolean values, so I will normally write:

VARIANT_BOOL vb_bool = VARIANT_FALSE;

// ... vb_bool set to something by some other code

bool myBool = (vb_bool == VARIANT_TRUE);

Are there tinier (as in "will compile to simpler x86 code"), valid ways to do it? Of course. Not worth it. This is guaranteed to work, so I can worry about my business logic.

Answer 3

Casting to bool is obviously wrong. Some people say (e.g. comments at BOOL vs. VARIANT_BOOL vs. BOOLEAN vs. bool) to compare to VARIANT_FALSE, but I would compare to both. That way you catch invalid values (anything but VARIANT_FALSE or VARIANT_TRUE) early.

e.g.

bool VariantBoolToBool(VARIANT_BOOL varFlag)
{
  bool boolFlag;

  switch( varFlag ) 
  {
    case VARIANT_TRUE:
        boolFlag = true;
        break;
    case VARIANT_FALSE:
        boolFlag = false;
        break;
    default:
        throw Exception("Not a valid value");
  }

  return boolFlag;
}

Answer 4

Declare this macro in one of your global headers.

#define b(X) ((X)!=VARIANT_FALSE)

EDIT: Much safer version:

inline bool b(VARIANT_BOOL v){return v!=VARIANT_FALSE;}

Answer 5

Compare to VARIANT_FALSE. There is a lot of buggy code out there that mistakenly passes in the C++ bool true value (cast to the integer value 1) to a function expecting VARIANT_BOOL. If you compare to VARIANT_FALSE, you will still get the correct expected value.

Answer 6

Standard C++ conversion rules rely on zero meaning false [and as 1800 INFORMATION points out, the TRUE variant is where the most confusion happens] and nothing more. Hence a static_cast would be best.

But in many cases, the code would be more readable as a comparison. In that case, VARIANT_BOOL is the thing to compare with.