а, понял что нужно:

спасибо доктор .. smile

voral, ну и на bash'е

#!/bin/bash

M2=4096
M1=64
X="$1"
(( Y = $X ))

(( B2 = Y / M2 ))
(( Y -= B2 * M2 ))
(( B1 = Y / M1 ))
(( B0 = Y - B1 * M1 ))

echo $B2 $B1 $B0
(( B2 += 14 * 16 ))
(( B1 += 128 ))
(( B0 += 128 ))
echo $B2 $B1 $B0

S=`printf "\x5Cx%X\x5Cx%X\x5Cx%X\n" $B2 $B1 $B0`

echo  "$S"
echo -e "$S"

gramozeka, про bash или про C?

я ни где не читал... Пришлось несколько софтин где с данными в хексе пришлось много работать да про работу с битами тут несколько раз последнее время говорили..... А с псевдографикой я не то что в линуксе я в си первый раз столкнулся, а из поса дока еще и про связь с 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);
    }
}

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

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

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

логично

попробую...
итак: имеются три основные битовые операции:
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 появился второй конвейер.

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

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

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

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

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

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

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