B_>  x ?  add(t) : remove (t);
B_>

(x ? add : remove) (t);

const Foo x (a() ? b() : c()); // даже copy constructible может не потребоваться
foo(d() ? e() : f());

// versus

/*nonconst*/Foo x; // default constructible, assignable
if(a()) x = b(); else x = c();

if(d()) foo(e()); else foo(f());

13.3.3.1.1 Standard conversion sequences
фрагмент из Table 9:
Conversion, Rank, Subclause

"Integral Promotion" Promotion 4.5
"Boolean conversions" Conversion 4.12

13.3.3.2 Ranking implicit conversion sequences

Standard conversion sequences are ordered by their ranks: an Exact Match is a better conversion than a Promotion,
which is a better conversion than a Conversion.

U>Покурил немного стандартик

An implicit conversion sequence is a sequence of conversions used to convert an argument in a function call to the type of the corresponding parameter of the function being called.

If either operand has a type that is a class or an enumeration, a user-defined operator function might be declared that implements this operator or a user-defined conversion can be necessary to convert the operand to a type that is appropriate for a built-in operator. In this case, overload resolution is used to determine which operator function or built-in operator is to be invoked to implement the operator. Therefore, the operator notation is first transformed to the equivalent function-call notation as summarized in Table 8

If no operand of an operator in an expression has a type that is a class or an enumeration, the operator is assumed to be a built-in operator and interpreted according to clause 5.

The == (equal to) and the != (not equal to) operators have the same semantic restrictions, conversions, and result type as the relational operators except for their lower precedence and truth-value result.

The usual arithmetic conversions are performed on operands of arithmetic or enumeration type.

Many binary operators that expect operands of arithmetic or enumeration type cause conversions and yield result types in a similar way. The purpose is to yield a common type, which is also the type of the result. This pattern is called the usual arithmetic conversions, which are defined as follows:

— If either operand is of type long double, the other shall be converted to long double.
— Otherwise, if either operand is double, the other shall be converted to double.
— Otherwise, if either operand is float, the other shall be converted to float.
— Otherwise, the integral promotions (4.5) shall be performed on both operands. [Footnote: As a consequence, operands of type bool, wchar_t, or an enumerated type are converted to some integral type]
— Then, if either operand is unsigned long the other shall be converted to unsigned long.
— Otherwise, if one operand is a long int and the other unsigned int, then if a long int can represent all the values of an unsigned int, the unsigned int shall be converted to a long int; otherwise both operands shall be converted to unsigned long int.
— Otherwise, if either operand is long, the other shall be converted to long.
— Otherwise, if either operand is unsigned, the other shall be converted to unsigned.

An rvalue of type bool can be converted to an rvalue of type int, with false becoming zero and true becoming one.

4.5 Integral promotions

4. An rvalue of type bool can be converted to an rvalue of type int, with false becoming zero and true
becoming one.

4.7 Integral conversions

4. If the destination type is bool, see 4.12. If the source type is bool, the value false is converted to zero
and the value true is converted to one.

if (int == bool)
if (bool == int)

AG>struct B {};
AG>struct D1 : B {};
AG>struct D2 : B {};

AG>B * f()
AG>{
AG>  return 0 ? new D1 : new D2; // error C2446: ':' : no conversion from 'D2 *' to 'D1 *'
AG>}
AG>

B * f()
{
  return 0 ? (B *)new D1 : new D2; // error C2446: ':' : no conversion from 'D2 *' to 'D1 *'
}

B_> x ? add(t) : remove(t);

B_> if (x) 
B_>   add(t);
B_> else
B_>   remove()t;

  x && add(t);

B_> if (x) 
B_>   add(t);

((x ? true : false) == true) ? add(t) : remove(t);

int i = какое нибудь число;
if (i) 
    foo ();

 int t = x ? 5 : 7;

  x ?  add(t) : remove (t);

 if (x) 
   add(t);
 else
   remove()t;

 или 
 
 if (x) add(t); else remove(t);

struct B {};
struct D1 : B {};
struct D2 : B {};

B * f()
{
  return 0 ? new D1 : new D2; // error C2446: ':' : no conversion from 'D2 *' to 'D1 *'
}

longName = very_very_very_long_function_name (argumentOne, argumentTwo, flag ? number : 45);

А>  return 0 ? (B *)new D1 : new D2;
А>

  return 0 ? static_cast<B*>(new D1) : new D2;

x ? add(t) : remove(t);

I>>((x ? true : false) == true) ? add(t) : remove(t);

CC>int i = какое нибудь число;
CC>if (i) 
CC>    foo ();

// If the function succeeds, the return value is nonzero.
// If the function fails, the return value is zero.

BOOL WINAPI CheckTokenMembership(HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember);

CC>BOOL WINAPI CheckTokenMembership(HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember);

bool GetCorrectAnswer ();
BOOL WINAPI GetSomething ();

if (GetSomething () == GetCorrectAnswer ()) ...

CC>if (GetSomething () == GetCorrectAnswer ()) ...

_>>>у меня еще с чистого C неприятие прямого сравнения с true. != false или в данном случае вообще if (x) гораздо лучше.
I>>Чем же сравнение с false лучше сравнения с true?
CC>Тем, что только ноль == false. А за true принимается любое ненулевое значение.

#include <iostream>

int main(int argc, char** argv)
{
  int x = 4;
  bool flag = true;
  bool result = (flag == x);
  std::cout << "Result = " << result << std::endl;
  return 0;
}

Result = 0

3.9.1 Fundamental types
...
6. Values of type bool are either true or false.42) [Note: there are no signed, unsigned, short, or
long bool types or values. ] As described below, bool values behave as integral types. Values of type
bool participate in integral promotions (4.5).

4 Standard conversions

TRUE == true всегда истинно