Re: Ух ё! signed/unsigned bool - C/C++

Случайно написал:

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

И заработало

Народ, почему это заработало? Зачем вообще в С++ signed/unsigned для bool?

После такой находки пошел выпил чайку и сразу подумалось о перегрузке:

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
}

Знает кто-нибудь нафига в С++ такие недо-типы? Это же еще хуже char, signed char, unsigned char. Если я верно понял, то signed и unsigned bool это typedef-ы соответственно:

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

Это умозаключение подтверждает тот факт, что на MS VS 2007.3 sizeof( unsigned int ) == sizeof( unsigned bool ) — true; sizeof( bool ) == sizeof( unsigned bool ) — false (прочем последний больше sizeof( bool ) в 4 раза).

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

Здравствуйте, anonim_44ax, Вы писали:

_>Случайно написал:
_>

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

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

_>Народ, почему это заработало? Зачем вообще в С++ signed/unsigned для bool?

MSVS... там ещё и не то работает

На самом деле в стандарте 3.9.1.6 чётко прописано "there are no signed, unsigned, short or long bool types or values". Так что не заморачивайтесь это открытие -- скорее из разряда "баги", чем "фичи".

Я бы вообще убрал слово unsigned.
ИМХО было бы лучше если были.

char, uchar, int, uint, bool, short, ushort ... и т.д.

Но это уже был бы не С.

Здравствуйте, anonim_44ax, Вы писали:

_>Случайно написал:
_>

_>signed bool test = -true; 
_>

Такое как-то сложно случайно написать =)

Здравствуйте, anonim_44ax, Вы писали:

_>Случайно написал:
_>

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

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

_>Народ, почему это заработало? Зачем вообще в С++ signed/unsigned для bool?

А почему ты решил, что в C++ они разрешены? См. п. 7.1.5.2 Simple type specifiers стандарта C++:

Table 7 summarizes the valid
Table 7—simple-type-specifiers

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

combinations of simple-type-specifiers and the types they specify.
 and the types they specify
 | Type -------- | “char” | “unsigned char” | “signed char” | “bool” | “unsigned int” | “unsigned int” | “int” | “int” | “int” short int | “unsigned short int” | “unsigned short int” | “unsigned long int” | “unsigned long int” | “long int” | “long int” | “long int” | “long int” | “short int” | “short int” | “short int” | “short int” | “wchar_t” | “float” | “double” | “long double” | “void”

_>Знает кто-нибудь нафига в С++ такие недо-типы? Это же еще хуже char, signed char, unsigned char. Если я верно понял, то signed и unsigned bool это typedef-ы
ээээ.. а что плохого в signed/unsigned char? char — это ведь всего навсегда целочисленный тип sizeof которого всегда равен 1

Вас же не удивляет signed/unsigned int, signed/unsigned short. char от них ничем кроме sizeof а не отличается.

Чтобы лучше ощутить всю комичность ситуации написал супер-код:

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

Сломал мозг пока пытался себе представить "знаковое и беззнаковое ничто"

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

А>ээээ.. а что плохого в signed/unsigned char? char — это ведь всего навсегда целочисленный тип sizeof которого всегда равен 1

Неприятность с signed char, unsigned char и char заключается в том, что это три разных типа (которые между прочим участвуют в перегрузке), что не всегда очевидно.

Здравствуйте, anonim_44ax, Вы писали:

_>Случайно написал:
_>

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

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

_>Народ, почему это заработало? Зачем вообще в С++ signed/unsigned для bool?

_>После такой находки пошел выпил чайку и сразу подумалось о перегрузке:
_>

_>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
_>}
_>

_>Знает кто-нибудь нафига в С++ такие недо-типы? Это же еще хуже char, signed char, unsigned char. Если я верно понял, то signed и unsigned bool это typedef-ы соответственно:
_>

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

_>Это умозаключение подтверждает тот факт, что на MS VS 2007.3 sizeof( unsigned int ) == sizeof( unsigned bool ) — true; sizeof( bool ) == sizeof( unsigned bool ) — false (прочем последний больше sizeof( bool ) в 4 раза).

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

).

Под 2008 студией

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

Самое удивительное — выскакивают ворнинги:
warning C4076: 'unsigned' : can not be used with type 'bool'
warning C4076: 'unsigned' : can not be used with type '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.

Похоже не работает, "мелкомягкий" компайлер просто приводит эти типы к unsigned int!!!

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

компилятора нет под рукой, но копчик мне подсказывает, что

true == -true

а также

-true == true

приняв во внимание, что с философской точки зрения false == -true, получаем:

false == -true == true -> false == true

как мы видим, MSVC++ активно участвует в улучшении нашей вселенной, упрощая фундаментальные основы и выходя на уровень абстракции, где не действуют законы логики

Здравствуйте, anonim_44ax, Вы писали:
_>

_>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

это компилируется или шутка такая?
Конечно шутка и конечно компилируется

Шутка потому, что использовать подобную "технику" программирования не имеет смысла.
Ну и по крайней мере на MS VS 2007.3 (нету другой под рукой) вполне успешно без карканья компилируется.

Здравствуйте, Ovl, Вы писали:

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

Ovl>компилятора нет под рукой, но копчик мне подсказывает, что
Ovl>

true == -true

Ovl>а также

-true == true

Копчик не прав. Выражение -true имеет тип int, и его значение равно -1. Перед вычислением сравнения к операнду true будет применено интегральное продвижение — неявное преобразование к типу int (в данном случае), в итоге сравниваться будут два значения типа int, одно из которых равно -1, а другое — равно 1.

Здравствуйте,

А я написал такую программку:

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)

Последнюю строчку кто-то может объяснить?

Здравствуйте, anonim_44ax, Вы писали:

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

Скорее "мнимая правда"

Здравствуйте, dmitry_npi, Вы писали:

_>Последнюю строчку кто-то может объяснить?

Декларация вызова функции. void игнорируется.

Здравствуйте, Masterkent, Вы писали:

M>Здравствуйте, Ovl, Вы писали:

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

Ovl>>компилятора нет под рукой, но копчик мне подсказывает, что
Ovl>>

M>true == -true
M>

Ovl>>а также
M>

M>-true == true
M>

M>Копчик не прав. Выражение -true имеет тип int, и его значение равно -1. Перед вычислением сравнения к операнду true будет применено интегральное продвижение — неявное преобразование к типу int (в данном случае), в итоге сравниваться будут два значения типа int, одно из которых равно -1, а другое — равно 1.

копчик прав, просто глуп. потому что он имел ввиду равенство в смысле if(true) == if(-true)

Здравствуйте, ned, Вы писали:

ned>Здравствуйте, dmitry_npi, Вы писали:

_>>Последнюю строчку кто-то может объяснить?

ned>Декларация вызова функции. void игнорируется.
Да я понял, что функция, но как компилятор это вывел? Ведь signed void() — это вызов конструктора типа signed void, то есть это выражение, но не декларация функции. Этот же смысл был и впосте раньше, когда человек возвращал это выражение из функции.
(VC++ 2008)

Здравствуйте, anonim_44ax, Вы писали:

_>Случайно написал:
_>

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

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

_>Народ, почему это заработало? Зачем вообще в С++ signed/unsigned для bool?

Смею разочаровать получи весь листинг твоего кода и окажется, что ты где-то написал #define bool int
только по этому. В общем, MSVC достаточно хорошо следует стандарту (хотя как и многих компиляторов бываю свои бзынки). часто конструкция #define bool int встречается в допотопных библиотеках. Иногда эти самые дефайны весьма мерзкая штука (т.к. не позволяют отличать bool от int, что в C++ более чем важно бывает, ну а по сути bool и int весьма разные типы в частности если вспомнить operator bool, который бывает весьма к месту частенько (bool используется как тип к которому стандартно приводятся данные в if-ах while-ах for-ах, в то же время вполне может существовать operator int для целого представления класса и тут-то и начинается маразм, когда хорошо работавший код быстро ломается (а иногда компилятор даже и не ругается) только из-за одного мерзкого #define-а потому как бла-бла-бла)).

Здравствуйте, dmitry_npi, Вы писали:

ned>>Декларация вызова функции. void игнорируется.
_>Да я понял, что функция, но как компилятор это вывел? Ведь signed void() — это вызов конструктора типа signed void, то есть это выражение, но не декларация функции. Этот же смысл был и впосте раньше, когда человек возвращал это выражение из функции.

Пытается угадать? Попробуй так:

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

	От:	anonim_44ax
	Дата:	02.06.09 14:10
	Оценка:	31 (2)

От:	Tilir	http://tilir.livejournal.com
Дата:	02.06.09 14:33
Оценка:	11 (3) +2

	От:	nen777w
	Дата:	02.06.09 14:37
	Оценка:

	От:	Аноним
	Дата:	02.06.09 14:39
	Оценка:

	От:	Masterkent
	Дата:	02.06.09 14:40
	Оценка:	2 (1)

	От:	dmitry_npi
	Дата:	03.06.09 05:29
	Оценка:

	От:	ned
	Дата:	03.06.09 06:34
	Оценка:	+1

	От:	ned
	Дата:	03.06.09 06:46
	Оценка:

	От:	Ovl
	Дата:	03.06.09 06:57
	Оценка: