Привет.

Попалась в коду такая строчка:

int foo(unsigned val)
{
    val &=(val-1);
    // ... остальное пропущенно

}

Вопрос, что такое unsigned? Я понимаю, что беззнаковый тип, но какой.
Если бы unsigned int — то все ясно, а есть просто, то что это?

И еще, объясните пожалуйста подробнее что это за выражение:

val&=(val-1)

И что оно делает при любом (unsigned) val?

Спасибо

Здравствуйте Аноним, Вы писали:

А>Привет.

А>Попалась в коду такая строчка:

А>

А>int foo(unsigned val)
А>{
А>    val &=(val-1);
А>    // ... остальное пропущенно

А>}

А>

А>Вопрос, что такое unsigned? Я понимаю, что беззнаковый тип, но какой.
А>Если бы unsigned int — то все ясно, а есть просто, то что это?

unsigned int

А>И еще, объясните пожалуйста подробнее что это за выражение:

А>val&=(val-1)

А>И что оно делает при любом (unsigned) val?

Оно выполняет двоичное AND с операндами val и val-1 и записывает результат в val.

А>Спасибо

You are welcome

Здравствуйте Аноним, Вы писали:

А>Вопрос, что такое unsigned? Я понимаю, что беззнаковый тип, но какой.
А>Если бы unsigned int — то все ясно, а есть просто, то что это?

Если полное имя типа состоит из двух или трех слов, последнее из которых int, это последнее слово можно опустить: short int можно записать как short, unsigned long int можно записать как unsigned long и т. п.

А>И еще, объясните пожалуйста подробнее что это за выражение:

А>val&=(val-1)

А>И что оно делает при любом (unsigned) val?

Сбрасывает самый младший установленный бит в val.

Здравствуйте Аноним, Вы писали:

А>Привет.

А>Попалась в коду такая строчка:

А>

А>int foo(unsigned val)
А>{
А>    val &=(val-1);
А>    // ... остальное пропущенно

А>}

А>

А>Вопрос, что такое unsigned? Я понимаю, что беззнаковый тип, но какой.
А>Если бы unsigned int — то все ясно, а есть просто, то что это?

А>И еще, объясните пожалуйста подробнее что это за выражение:

А>val&=(val-1)

А>И что оно делает при любом (unsigned) val?

А>Спасибо

1. По моему unsigned — unsigned int
2. val&=(val-1) -> val = val & (val-1)
то есть побитовое "и"

Здравствуйте Аноним, Вы писали:

А>Привет.

А>Попалась в коду такая строчка:

А>

А>int foo(unsigned val)
А>{
А>    val &=(val-1);
А>    // ... остальное пропущенно

А>}

А>

А>Вопрос, что такое unsigned? Я понимаю, что беззнаковый тип, но какой.

Это unsigned int. Такое объявление пришло от языка C, в котором тип int подразумевался обычно по умолчанию.

А>val&=(val-1)


А>И что оно делает при любом (unsigned) val?

"Ищет" самый младший (самый правый) бит, установленный в единицу, и обнуляет его.

P.S. Тип для unsigned-а, можно было и самомо посмотреть, через конструкцию

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

Здравствуйте Аноним, Вы писали:

А>Привет.

А>Попалась в коду такая строчка:

А>

А>int foo(unsigned val)
А>{
А>    val &=(val-1);
А>    // ... остальное пропущенно

А>}

А>

А>Вопрос, что такое unsigned? Я понимаю, что беззнаковый тип, но какой.
А>Если бы unsigned int — то все ясно, а есть просто, то что это?

Именно unsigned int и есть. В таких случаях int можно опустить.

А>И еще, объясните пожалуйста подробнее что это за выражение:
А>val&=(val-1)
val = val & (val-1)
А>И что оно делает при любом (unsigned) val?
А>Спасибо

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

А>>val&=(val-1)


А>>И что оно делает при любом (unsigned) val?

DG>"Ищет" самый младший (самый правый) бит, установленный в единицу, и обнуляет его.

Вопрос конечно ламерский, но число val то само как измениться?
Если val было к примеру 10, то после val&=(val-1) что будет в val?
Я понимаю, можно запустить IDE и посмотреть, но хотелось бы понять все эти битовые операции.
Можно ли без компилятора узнать что будет результатом при любом начальном val?

Спасибо

Здравствуйте Аноним, Вы писали:

А>>>И что оно делает при любом (unsigned) val?

DG>>"Ищет" самый младший (самый правый) бит, установленный в единицу, и обнуляет его.

А>Вопрос конечно ламерский, но число val то само как измениться?

Число val (если его записать в двоичном виде) останется без изменений, не считая того, что у него обнулится самый младший единичный бит.

А>Если val было к примеру 10, то после val&=(val-1) что будет в val?

Переводим в уме 10(dec) в двоичную систему 1010(bin), обнуляем младшую единицу 1000(bin), переводим из двоичной обратно в десятичную, получаем 8.

Это было логическое объяснение данной операции, а теперь что происходит на самом деле(физика):

val&=val-1 -> val = val & (val -1) -> val = 10 & (10 — 1) -> val = 1010(bin) & (1010(bin) — 1) -> val = 1010(bin) & 1001(bin) -> val = 1000(bin) -> val = 8




А>Я понимаю, можно запустить IDE и посмотреть, но хотелось бы понять все эти битовые операции.
А>Можно ли без компилятора узнать что будет результатом при любом начальном val?

см. выше

А>>Вопрос конечно ламерский, но число val то само как измениться?


Ребят, все и так ясно, нечего флейм плодить, но по сути вопроса выше — а вы не замечали такие вещи:

int foo(unsigned val)
{
    val &=(val-1);
    // ... остальное пропущено

}

Там жирненьким с курсивом выделено... То есть чего-то возвращается, скорее всего — измененное val... Собсно, все

Спасибо, чуток понял! :)

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

А>>Если val было к примеру 10, то после val&=(val-1) что будет в val?

DG>Переводим в уме 10(dec) в двоичную систему 1010(bin), обнуляем младшую единицу 1000(bin), переводим из двоичной обратно в десятичную, получаем 8.

по-моему 10(dec) — 1(dec) = 9
вы второй справа бит поменяли
и в результате получится 1000(bin)= 8(dec)?

DG>Это было логическое объяснение данной операции, а теперь что происходит на самом деле(физика):

DG>val&=val-1 -> val = val & (val -1) -> val = 10 & (10 — 1) -> val = 1010(bin) & (1010(bin) — 1) -> val = 1010(bin) & 1001(bin) -> val = 1000(bin) -> val = 8




А>>Я понимаю, можно запустить IDE и посмотреть, но хотелось бы понять все эти битовые операции.
А>>Можно ли без компилятора узнать что будет результатом при любом начальном val?

DG>см. выше

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

А>>>Если val было к примеру 10, то после val&=(val-1) что будет в val?

DG>>Переводим в уме 10(dec) в двоичную систему 1010(bin), обнуляем младшую единицу 1000(bin), переводим из двоичной обратно в десятичную, получаем 8.

E>по-моему 10(dec) — 1(dec) = 9
E>вы второй справа бит поменяли

Я имел ввиду сразу конечный результат операции val & (val — 1), которая как раз обнуляет младший единичный бит, а не промежуточный как ты: (val-1)

E>и в результате получится 1000(bin)= 8(dec)?

да. там же ниже, написана "физика", как это получается

A>Сбрасывает самый младший установленный бит в val.

Чего то я не понимаю.. глупый, что ли, совсем стал?
Два человека написали, что выражение val &= (val-1); сбрасывает младший бит в val..
Сбрасывать-то оно сбрасывает.. а остальные биты как же?

Например:

в десятичном виде | в двоичном виде
-----------------------------------------------------
10 & (10-1) = 8 ; | 1010 & 1001 = 1000;
12 & (12-1) = 8 ; | 1100 & 1011 = 1000;
24 & (24-1) = 16; | 11000 & 10111 = 10000;

Если назначение данного выражения — только сбрасывать младший бит в val, не проще ли было написать val &= 0xfffffffe; ?

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

L>Если назначение данного выражения — только сбрасывать младший бит в val, не проще ли было написать val &= 0xfffffffe; ?

Сбрасывает самый младший установленный бит

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

A>>Сбрасывает самый младший установленный бит в val.

L>Чего то я не понимаю.. глупый, что ли, совсем стал?
L>Два человека написали, что выражение val &= (val-1); сбрасывает младший бит в val..
L>Сбрасывать-то оно сбрасывает.. а остальные биты как же?

L>Например:

L>в десятичном виде | в двоичном виде
L>-----------------------------------------------------
L>10 & (10-1) = 8 ; | 1010 & 1001 = 1000;
L>12 & (12-1) = 8 ; | 1100 & 1011 = 1000;
L>24 & (24-1) = 16; | 11000 & 10111 = 10000;

L>Если назначение данного выражения — только сбрасывать младший бит в val, не проще ли было написать val &= 0xfffffffe; ?

самый младший установленный бит, а не просто младший бит.

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

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

L>>Если назначение данного выражения — только сбрасывать младший бит в val, не проще ли было написать val &= 0xfffffffe; ?

Р>Сбрасывает самый младший установленный бит

А при неустановленном бите val корежится.. Может, и другие какие соображения были, чтобы написать такое выражение? Ведь val &= 0xFFFFFFFE более прямолинейно и понятно.

Vi2>самый младший установленный бит, а не просто младший бит.

Дошло.

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

A>>Сбрасывает самый младший установленный бит в val.

L>Чего то я не понимаю.. глупый, что ли, совсем стал?
L>Два человека написали, что выражение val &= (val-1); сбрасывает младший бит в val..
L>Сбрасывать-то оно сбрасывает.. а остальные биты как же?

L>Например:

L>в десятичном виде | в двоичном виде
L>-----------------------------------------------------
L>10 & (10-1) = 8 ; | 1010 & 1001 = 1000;
L>12 & (12-1) = 8 ; | 1100 & 1011 = 1000;
L>24 & (24-1) = 16; | 11000 & 10111 = 10000;

L>Если назначение данного выражения — только сбрасывать младший бит в val, не проще ли было написать val &= 0xfffffffe; ?

Выражение val &= (val — 1) сбрасывает не МЛАДШИЙ бит в числе val, а ПОСЛЕДНИЙ установленный бит.
Например,

• 100100 & (100100 — 1) == 100000
  
• 110010 & (110010 — 1) == 110000

MNZ>Выражение val &= (val — 1) сбрасывает не МЛАДШИЙ бит в числе val, а ПОСЛЕДНИЙ установленный бит.
MNZ>Например,

MNZ>

MNZ>
• 100100 & (100100 — 1) == 100000
  MNZ>
• 110010 & (110010 — 1) == 110000
  MNZ>

Уже понял. Мне стыдно...

Здравствуйте Аноним, Вы писали:

А>Привет.

А>Попалась в коду такая строчка:

А>

А>int foo(unsigned val)
А>{
А>    val &=(val-1);
А>    // ... остальное пропущенно

А>}

А>

А>Вопрос, что такое unsigned? Я понимаю, что беззнаковый тип, но какой.
А>Если бы unsigned int — то все ясно, а есть просто, то что это?

А>И еще, объясните пожалуйста подробнее что это за выражение:

А>val&=(val-1)

А>И что оно делает при любом (unsigned) val?

А>Спасибо
Данное выражение может быть использовано:
1. для определения значения val как стпень 2-х — (val &= (val-1)) == 0;
2. для подсчета количества единиц байте, слове и т.д. (естественно требуется цикл).