Привет.
Есть такие вещи, которые до сих пор меня в ступор ставят.

Вот пример:


Кое-где увидел, как мельком взглянув на такой код, программист сказал, "будет 99"

Скажите, это действительно должно быть так просто? Лично для меня нет пока.

И ещё. 
Стандарт ведь не говорит, что делает такой код:


Разные компиляторы скомпилируют по-разному. VC++ 2008 - 4. gcc - 3.

Или


Вопрос: что делать, чтобы не теряться в таких ситуациях и чётко всё видеть и чувствовать. 
Если читать книги, то какие? Не во всех освещены такие моменты?

P.S. Знаю, что это всё неформально зовётся "г-о-в-н--о-кодом" и в реальных проектах не применяется, но на собеседованиях обычно этим и заваливают по отзывам очевидцев.


Это сообщение отредактировал(а) Riddik - 27.6.2009, 01:28

Просто было бы, если бы был опыт работы с битовыми операциями над шестнадцатиричными цифрами.
& 0xF  и >> 4 для 16ричных грубо говоря такие же простые операции как /10 и %10 для 10ричных 

Добавлено через 1 минуту и 38 секунд

учиться, учиться и учиться ! © В.И.Ленин 

Меня тож битовые операции подвешивают  

Riddik, надо учитывать, в каком проекте присутствовал подобный код, какие условия были. В общем случае я назову его нечитабельным - код несостоятельный (опять так - зависит от задачи). 


Это сообщение отредактировал(а) zkv - 27.6.2009, 14:20

не ему счет поручают, когда электричества нет?   

Riddik, с опытом что-то придет, безусловно. ты ведь в принципе можешь понять выражение. а на лету или нет - вопрос практики. 
и прочие ситуации - то же самое. придет. придет и понимание, что мастерство не в лихо закрученных выражениях, а в читабельном коде, который лет через 10 будет читать понятно и приятно.

Заняло 3 минуты (так делать нечего было)
Перепишем в двоичной
val=10011001
------------
10011001 &
11110000 =
10010000 >>4=
00001001 ~ 9
9*10=90

10011001 &
00001111=
00001001 ~9

9+90=99
========
Теперь я супер программист  

Это сообщение отредактировал(а) Irdis - 27.6.2009, 13:24

Поясню в чём секрет мастерства
Перевод из 16ричной системы в двоичную
0->0000
1->0001
2->0010
...
8->1000
...
A->1010
B->1011
...
F->1111
Допустим число F81 легко перевести с помощью простой подстановки из приведенной таблицы 1111 1000 0001 (обратная операция равносильна) (кстати в восьмеричной всё аналогично, за исключением рассматриваем таблицу до 7 и числа 000 001 010)
теперь & ну и |
1 &(|) 1 = 1 (1)
1 &(|) 0 = 0 (1)
0 &(|) 1 = 0 (1)
0 &(|) 0 = 0 (0)
1110111000011 &
1111100000000=
1110100000000 (смотри на столбцы)
>> x  просто сдвиг вправо на x бит
====================
ш++ или ++ш
o=i++; //(могу ошибаться) сначала идёт присваивание а потом(!после! всех операции) увеличение на единицу значения i
o=++i // сначала(!до! всех операций) увеличение на единицу значения i, а потом присваивание 
пс gcc - шлак видимо разработчики не читали Страуструпа  

Это сообщение отредактировал(а) Irdis - 27.6.2009, 14:25

никому не говорите: в вверхней строчке был ответ 


***

не соглашусь. обычно заваливают, если кандидат слишком высокого о себе мнения, а на самом деле ничего не знает 

Это сообщение отредактировал(а) zim22 - 27.6.2009, 13:56

Интересно   

А разве 0x99 и 99 это одно и то же ?

Irdis, Твои посты нужно в вики вывесить!

 В битовое представление переводить в данном случае не обязательно, можно решить гораздо проще :
(хотя чтоб знать как применять операции сразу к 16 ричным цифрам нужен опыт, о котором говорилось выше  )



Вы забываете об одном, что операции проводится над числом которое вначале считывается из памяти, а потом туда записывается.
Так вот в представленном примере стандарт не гарантирует сохранения изменения результата в памяти до того как им воспользуется во второй раз - отсюда и неопределенное поведение.



Это сообщение отредактировал(а) mes - 27.6.2009, 15:17

 попробуйте поподставлять значения в диапазоне от нуля до 99

Вы о том что что если вместо 0х99 подставить 0х13 то получится 13 вместо 99 ?
Но во первых это не отменяет вопрос Ridder`a, о том как человек сходу догадался, что из 0х99 должно получиться именно 99.
Во вторых подставляю как Вы просили val = 0x2D и сколько будет результат ?   

  

вы на этот вопрос уже ответили.

вы не честно играете. каждая цифра должна была находиться в диапазоне от 0 до 9, чтобы "прикол" работал 

а о диапaзоне не было ни слова 



Это сообщение отредактировал(а) mes - 27.6.2009, 15:43

2*10+D = 20+13 = 33, прикол работает...

Добавлено через 1 минуту и 56 секунд

если бы было выражение ((val & 0xF0) >> 4) * 16 + (val & 0x0F);
то осталось бы 0x99, а так просто перевели 16-ричное число по десятичному основанию.

Сам спрашивал у собеседуемого и ждал вполне конкретный ответ: это Undefined behaviour.
И не с целью завалить, а с целью узнать, отдает он себе отчет, что такой код писать не следует или нет...

  Ну это специфика, которая не везде используется. В низкоуровневом программировании, да, а так нечасто. С++ весьма обширен, так что при большом желании подловить можно и Страуструпа. Мало того что нужно знать кучу нюансов правильной работы, так еще нужно знать как неправильно писать.