在C ++中将内置类型（int）转换为bool的首选方法是什么？

Question

When programming with Visual C++, I think every developer is used to see the warning

warning C4800: 'BOOL' : forcing value to bool 'true' or 'false'

from time to time. The reason obviously is that BOOL is defined as int and directly assigning any of the built-in numerical types to bool is considered a bad idea.

So my question is now, given any built-in numerical type (int, short, ...) that is to be interpreted as a boolean value, what is the/your preferred way of actually storing that value into a variable of type bool ?

_{Note: While mixing BOOL and bool is probably a bad idea, I think the problem will inevitably pop up whether on Windows or somewhere else, so I think this question is neither Visual-C++ nor Windows specific.}

Given int nBoolean; I prefer this style:

• bool b = nBoolean?true:false;

The following might be alternatives:

• bool b = !!nBoolean;

• bool b = (nBoolean != 0);

Is there a generally preferred way? Rationale?

I should add: Since I only work with Visual-C++ I cannot really say if this is a VC++ specific question or if the same problem pops up with other compilers. So it would be interesting to specifically hear from g++ or users how they handle the int->bool case.

Regarding Standard C++: As David Thornley notes in a comment, the C++ Standard does not require this behavior. In fact it seems to explicitly allow this, so one might consider this a VC++ weirdness. To quote the N3029 draft (which is what I have around atm.):

4.12 Boolean conversions [conv.bool]

A prvalue of arithmetic, unscoped enumeration, pointer, or pointer to member type can be converted to a prvalue of type bool. A zero value, null pointer value, or null member pointer value is converted to false; any other value is converted to true. (...)

Answer 1

In the context of using win32 SDK and MFC, I tend to write it always this way. It's explicit.

bool b = (myBOOL != FALSE);

EDIT: I have edited :-) cause i'm not sure myBOOL == TRUE works for all implementation of BOOL and I can assume that FALSE may have the 0 value most of the time.

Answer 2

我假设的正确方法是：

bool b = static_cast<bool>(val);

Answer 3

I cast my vote for

BOOL nBoolean;
bool b = (nBoolean != 0);

Reason? Since BOOL resolves to an int, one should compare it to an int when converting to bool. The other two methods: !!nBoolean and nBoolean?true:false treat nBoolean as as logical value and therefore perform an implicit cast conversion.

Answer 4

Three good ways:

static_cast<bool>( whatever )
bool( whatever )
!!whatever

Personally I prefer the last, but *nix folks may react negatively (not needed for those compilers, so not familiar with that idiom).

One reason that the last one is good is that it shuts up Visual C++ (sillywarning suppression).

Ungood ways include comparing with true or false , especially the former.

Cheers & hth.,

Answer 5

I tend to write it always this way. .

bool b = !!myBOOL;

It is clearer (well as an English speaker, I am used to double-negatives....)

It is also safer and avoids mistakes like:

bool b = (myBOOL = FALSE); //oops!

Also, I am of the opinion that booleans should never be compared using == or != rather && should be used. As soon as == or != is used the boolean variable is no longer treated as a boolean but as an integral value which defeats the purpose of boolean.

Answer 6

There is no preferred way in C++ , since the C++ Std simply allows the integral conversion from int to bool . (So the preferred way wrt the Std would be bool b = i; .)

That said, judging from the other answers, there does not even seem to be an accepted way to do it in Visual C++ (MS) although the MSDN page states

... If you cannot rewrite the expression to use type bool, then you can add "!=0" to the expression, which gives the expression type bool. ...

So one might conclude that MS recommends to use the !=0 comparison, although I, personally, think it's the worst of all the warning-supressing alterantives presented in the question and the answers here: The "type" in the source code is BOOL , and even though it's really just an int at least one should compare a " BOOL " with !=FALSE like has been proposed in some other answers.

Answer 7

If this bothered me, I would write a helper function like

inline bool to_bool(BOOL b) {...}

which would hide one of the proposed implementations inside it. And never think about this again :)