именно это - все современные, кроме поделия от М$, а полностью стандарт поддерживают (по слухам) только sun'овский и то, что сделало IBM.

угу... впрочем, в контексте сабжа трудно не согласится - в венде всё через /dev/ass  smile

да... что-то мне занесло  :lol:

все компиляторы это пожрут?

именно это - все современные, кроме поделия от М$, а полностью стандарт поддерживают (по слухам) только sun'овский и то, что сделало IBM.

эмм... я тоже хочу такую траву.

сложение по модулю 2 это xor

угу. там чуть ниже про XOR есть.

все компиляторы это пожрут?

повлияет, если процессор и компилятор по разному смотрят на порядок...

сложение по модулю 2 это xor

С99 с его uint32_t спасёт отца русской демократии...

не должен, но я бы 3 раза проверил если бы работал с биг-эндингом... а вот приведение типов разного размера он может порушить...

кстати в учебнике об этом совсем мало и ни одного практического примера кроме умножения ..

дык говорю-же: слабое место Си
не сказать что баг, но не иссякающий  источник багов...
вроде побочных эффектов.

Кстати, приоритеты не очень логичные, и лучше не писать в одну строчку. Лучше по одной операции в одной строке. Тоже кладезь багов...

В паскакалях есть "наборы", которые, как я понял, те-же булевы операции. Но они огорожены. А тут... А ещё порядок байт вообще-говоря разный бывает, обычно сначала младший, но не всегда. Естественно, порядок байтов влияет на сдвиг.

На практике, сдвигами можно заменить умножение на константу. Например
(x << 1) + (x << 3) == 2*x+8*x == 10*x.
(опять таки не факт, что это быстрее. А если даже быстрее, не факт, что компилятор об этом не знает. Я уже так нарывался - мучаешься, пишешь... А потом оказывается, что компилятор написал даже лучше меня.)

или на пальцах растолкуйте

попробую...
итак: имеются три основные битовые операции:
1) инверсия

0 => 1
1 => 0

2)логическое И

0 & 0 => 0
0 & 1 => 0
1 & 0 => 0
1 & 1 => 1

3) логическое ИЛИ

0 | 0 => 0
0 | 1 => 1
1 | 0 => 1
1 | 1 => 1

В Си логические операции выполняются над всеми байтами сразу. Обычно используют тип unsigned, который имеет длину типичную для машинного слова (32 или 64 бита сегодня).
Есть ещё операция ^
x ^ y == x & ~y | ~x & y
Она работает как ИЛИ, только 1 ^ 1 => 0. Потому и называется "исключающее или", или короче XOR.

Приоритеты:
~ самый высокий (инверсия)
&
|

(из-за приоритетов & иногда называют "логическим умножением", а | "логическим сложением". Ну и из-за правил. Это действительно сложение, но по модулю 2. Т.е. двойка откидывается. Потому 1+1 => 2 => 2+0 => 0(mod2))

Биты двигать нельзя (К.О.), но слова из многих бит - можно. И влево, и вправо. Выдвигаемые биты бесследно исчезают (потому-то это слабое место - всегда надо помнить о потере информации).

x << n это сдвиг x влево на n битов. Операция бинарная, сам x не меняется.
x >> n это сдвиг вправо.

Сколько битов в unsigned - никто не знает. Биты выдвигаются в никуда. Потому пользоваться сдвигами в Си == ходить по минному полю.
Вот voral потренировался сегодня, завтра радостно что-то напишет. А после завтра это рухнет  :O
Ибо, как именно двигаются слова - в стандарте не определено (особенно знаковые), а значит, сегодня они двигаются так,  а завтра - эдак.

И тем не менее, их иногда приходится применять. Ибо - быстро. x<<1 это тоже самое, что x*2, но намного быстрее. (но опять-таки - не всегда. 128<<1 == 0, если 128 - это char).

Логические операции применяются шире. Иногда удобно делать логику именно на битах. ИМХО можно полагать, что unsigned это как минимум 32 бита. Хотя такой быдлокод ОБЯЗАТЕЛЬНО надо подробно прокоментировать, что-бы починить его, когда он сломается.

Кстати, чисто заменой побитовых операций на обычные, можно значительно ускорить работу программы (ага, как это и не парадоксально). В частности сказывается то, что CPU распараллеливает не только данные, но и операции. Потому далеко не факт, что одна операция над двумя битами будет быстрее, чем две операции над двумя числами. Ещё в iP1 появился второй конвейер.

между прочим - зря. так никто не делает.
битовые операции - слабое место С.

Если честно, я еще и их на этом примере не много погонял (много, что в итоге осталось за кадром) т.к. на практике с битовыми операциями сталкивался от силы пару раз.

логично

#include <stdio.h>
#include <string.h>

unsigned getcode(unsigned index)
{
    unsigned a = index & 0xF000;
    a >>=12;
    unsigned b = index & 0xfc0;
    b <<= 2;
    unsigned c = index & 0x3f;
    c <<=16;
    return a | b | c | 0x8080e0;
}

unsigned re(unsigned index)
{
    unsigned a = index & 0xFF0000;
    a >>= 16;
    unsigned b = index & 0xff00;
    unsigned c = index & 0xff;
    c <<= 16;
    return a | b | c;
}

int main()
{
    unsigned code;
    int i, j;
    char str[8];
    printf("┏━━━━┯━━━━━━┯━┳━━━━┯━━━━━━┯━┳━━━━┯━━━━━━┯━┳━━━━┯━━━━━━┯━┓\n");
    j = 1;
    for (i = 0x2500;i<=0x259F;i++)
    {
        if(j == 1)
            printf("┃");
        code = getcode(i);
        memcpy(str, &code, sizeof(unsigned));
        printf("%04x│%06x│%s┃", i, re(code), str);
        if(j >= 4)
        {
            printf("\n");
            j = 0;
        }
        j++;
    }
    printf("┗━━━━┷━━━━━━┷━┻━━━━┷━━━━━━┷━┻━━━━┷━━━━━━┷━┻━━━━┷━━━━━━┷━┛\n");
    return 0;
}

Пришлось несколько софтин где с данными в хексе пришлось много работать да про работу с битами тут несколько раз последнее время говорили..... А с псевдографикой я не то что в линуксе я в си первый раз столкнулся, а из поса дока еще и про связь с utf8 узнал.... Стало интересно поковырять. Вот табличку варганил

между прочим - зря. так никто не делает.
битовые операции - слабое место С.

смените плюс на |.
оно конечно и так работает, но некрасиво.

ну раз такое дело ткните носом где об этих алгоритмах почитать .. а то я дальше своей подписи  :O не продвинулся ..

я ни где не читал... Пришлось несколько софтин где с данными в хексе пришлось много работать да про работу с битами тут несколько раз последнее время говорили..... А с псевдографикой я не то что в линуксе я в си первый раз столкнулся, а из поса дока еще и про связь с utf8 узнал.... Стало интересно поковырять. Вот табличку варганил

#include <stdio.h>
unsigned int getcode(unsigned int index)
{
    return ((index & 0xF000)>>12) + ((index & 0xfc0)<<2) + ((index & 0x3f)<<16) + 0x8080e0;
}
unsigned int re(unsigned int index)
{
    return ((index & 0xFF0000)>>16) + (index & 0xff00) + ((index & 0xff)<<16);
}
main()
{
    unsigned int test1=0;
    unsigned int *wchar1 = &test1;
    int i;
    for (i = 0x2500;i<=0x259F;i++)
    {
        test1 = getcode(i);
        printf("%x\t%x\t%s\n",i, re(test1),wchar1);
    }
}