signed void foo( unsigned bool b )
{
   return signed void();
}
int main()
{
   std::cout << foo( -true );
}

signed bool test = -true; ///< MS VS watch кстати говорит, что test имеет тип int  :xz:

void foo( bool ){}          ///< 1
void foo( signed bool ){}   ///< 2
void foo( unsigned bool ){} ///< 3 - (а здесь MS VS watch видит unsigned int)
//void foo( unsigned int ){}  ///< 4 - а вот если это откомментировать, то будет compiler-error - function already has body

int main()
{
   signed bool test = -true;
   foo( test ); ///< 2
   foo( false ); ///< 1
   foo( unsigned bool( test ) ); ///< 3
}

typedef unsigned int unsigned bool;
typedef signed int signed bool;

signed double float void bool int long b;

std::cout << typeid(int()).name() << std::endl;

The ambiguity arising from the similarity between a function-style cast and a type-id can occur in different contexts. The ambiguity appears as a choice between a function-style cast expression and a declaration of a type. The resolution is that any construct that could possibly be a type-id in its syntactic context shall be considered a type-id.

_>signed bool test = -true; ///< MS VS watch кстати говорит, что test имеет тип int  :xz: 
_>

_>И заработало

Table 7 summarizes the valid combinations of simple-type-specifiers and the types they specify.

Table 7—simple-type-specifiers and the types they specify

Specifier(s)       | Type
-----------------------------------------
type-name          | the type named
char               | “char”
unsigned char      | “unsigned char”
signed char        | “signed char”
bool               | “bool”
unsigned           | “unsigned int”
unsigned int       | “unsigned int”
signed             | “int”
signed int         | “int”
int                | “int”
unsigned short int | “unsigned short int”
unsigned short     | “unsigned short int”
unsigned long int  | “unsigned long int”
unsigned long      | “unsigned long int”
signed long int    | “long int”
signed long        | “long int”
long int           | “long int”
long               | “long int”
signed short int   | “short int”
signed short       | “short int”
short int          | “short int”
short              | “short int”
wchar_t            | “wchar_t”
float              | “float”
double             | “double”
long double        | “long double”
void               | “void”

_>signed bool test = -true; ///< MS VS watch кстати говорит, что test имеет тип int  :xz: 
_>

_>И заработало

_>void foo( bool ){}          ///< 1
_>void foo( signed bool ){}   ///< 2
_>void foo( unsigned bool ){} ///< 3 - (а здесь MS VS watch видит unsigned int)
_>//void foo( unsigned int ){}  ///< 4 - а вот если это откомментировать, то будет compiler-error - function already has body

_>int main()
_>{
_>   signed bool test = -true;
_>   foo( test ); ///< 2
_>   foo( false ); ///< 1
_>   foo( unsigned bool( test ) ); ///< 3
_>}
_>

_>typedef unsigned int unsigned bool;
_>typedef signed int signed bool;
_>

_>Короче, прикольный язык С++ всегда есть что-то новое и непонятное (многие бы сказали бессмысленное ).

sizeof( unsigned int ) == sizeof( unsigned bool )
sizeof( unsigned int ) == sizeof( unsigned double )

Error Message:
'typemod' : can not be used with type 'typename'
A type modifier, whether it is signed or unsigned, cannot be used with a noninteger type. typemod is ignored.

_>Хотя вроде "правда с минусом" звучит более-менее логично (и значит пожалуй "неправда")

true == -true

-true == true

_>signed void foo( unsigned bool b )
_>{
_>   return signed void();
_>}
_>int main()
_>{
_>   std::cout << foo( -true );
_>}
_>

 void foo0(  )
{   bool();
    void();
}

0x004012a6 <_Z4foo0v+0>:\tpush   %ebp
0x004012a7 <_Z4foo0v+1>:\tmov    %esp,%ebp
0x004012a9 <_Z4foo0v+3>:\tpop    %ebp
0x004012aa <_Z4foo0v+4>:\tret

_>>Хотя вроде "правда с минусом" звучит более-менее логично (и значит пожалуй "неправда")

true == -true

-true == true

int main()
{
    signed bool b1;
    unsigned bool b2;
    bool b;
    std::cout << typeid(b1).name() << std::endl;
    std::cout << typeid(b2).name() << std::endl;
    std::cout << typeid(-true).name() << std::endl;
    std::cout << typeid(signed void()).name() << std::endl;
}

int
unsigned int
int
int __cdecl(void)

std::cout << typeid(bool()).name() << std::endl;
std::cout << typeid(bool(true)).name() << std::endl;

void fun()
{  
  return void(9.);
}
bool boo()
{   return bool();
  //return bool(fun()); -- не хочет :xz: 
}

T x = T();

По этой причине для встроенных типов можно явно вызывать стандартный конструктор, который инициализирует их нулём (или значением false для bool), т.е. int() даёт нуль.

The expression T(), where T is a simple-type-specifier (7.1.5.2) for a non-array complete object type or
the (possibly cv-qualified) void type, creates an rvalue of the specified type, whose value is determined by
default-initialization (8.5; no initialization is done for the void() case). [Note: if T is a non-class type
that is cv-qualified, the cv-qualifiers are ignored when determining the type of the resulting rvalue (3.10).]