Некоторые случайные вопросы C (ASCII волшебные и побитовые операторы)

Это произведет спам:

char a = 3; 
int x = a - '0';

Это отличается - отмечают кавычки:

char a = '3'; 
int x = a - '0';

char тип данных хранит число это идентификаторы символ. Символы для цифр 0 до 9 являются всеми друг рядом с другом в списке кода символа, поэтому при вычитании кода для '0' из кода для '9' Вы получаете ответ 9. Таким образом, это повернет код символа цифры в целочисленное значение цифры.

(~pointer->intX & (1 << i))

Это будет интерпретироваться if оператор как верный, если это является ненулевым. Существует три различных используемые побитовых оператора.

~ оператор зеркально отражает все биты в числе, итак, если pointer->intX был 01101010, затем ~pointer->intX будет 10010101. (Обратите внимание, что повсюду, я иллюстрирую содержание байта. Если бы это было 32-разрядное целое число, то я должен был бы записать 32 цифры 1 с и 0s).

И оператор комбинирует два числа в одно число, путем контакта с каждым битом отдельно. Получающийся бит - только 1, если оба входные биты равняются 1. Таким образом, если левая сторона 00101001 и правая сторона 00001011, результат будет 00001001.

Наконец, << сдвиг влево средств. Если Вы запустите с 00000001 и сдвиг влево это тремя местами, то Вы будете иметь 00001000. Таким образом, выражение (1 <<i) производит значение, где бит, я включаюсь, и другие, все выключают.

Соединяя все это, это тестирует если бит i выключен (обнуляют) в pointer->intX.

Таким образом, Вы можете выяснять что ~(1 << i) делает. Если i 4, вещь в скобках будет 00010000, и таким образом, все это будет 11101111.

ret |= ROW;

Тот эквивалентен:

ret = ret | ROW;

| оператор похож & за исключением того, что получающийся бит равняется 1, если любой из входных битов 1. Итак, если ret 00100000 и ROW 00000010, результат будет 00100010.

ret |= ROW;

эквивалентно

ret = ret | ROW;

Для char a = 3; int x = a - '0'; Я думаю, что Вы имели в виду char a = '3'; int x = a - '0';. Достаточно легко понять, понимаете ли Вы, что в ASCII числа существуют порядка, как '0', '1', '2'... Таким образом, если '0' 48, и '1' 49, то '1' - '0' 1.

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

010 & 111 = 010
010 | 111 = 111
010 ^ 111 = 101
~010 = 101

Я думаю, что у Вас, вероятно, есть опечатка, и предназначенный:

char a = '3';

Причина это работает, состоит в том, что все числа существуют порядка, и '0' является первым. Очевидно, '0' - '0' = 0. '1' - '0' = 1, так как символьное значение для '1' является одним большим, чем символьное значение для '0'. И т.д.

Вычитание обманывает Вас ссылочные работы, потому что числа ASCII расположены в порядке возрастания, начиная с нуля. Таким образом, если ASCII '0' является значением 48 (и это), затем '1' значение 49, '2' 50, и т.д. Поэтому ASCII ('1') - ASCII ('0') = 49 - 48 = 1.

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

Давайте сломаем Ваш пример:

(1 << i) - это лево-смещает постоянный 1 на i биты. Таким образом, если i=0, результат десятичный 1. Если я = 1, это смещает разрядный налево, заделывая с нулями, приводя к двоичным 0010 или десятичным 2. Если я = 2, Вы смещаете бит два налево, заделывая с нулями, приводя к двоичным 0100 или десятичным 4, и т.д.

~pointer->intX - это принимает значение intX члена указателя и инвертирует его биты, устанавливая все нули на и наоборот.

& - оператор амперсанда делает поразрядное И сравнение. Результаты этого будут 1 везде, где и левая и правая сторона выражения равняется 1, и 0 иначе.

Таким образом, тест успешно выполнится если pointer->intX имеет 0 битов в ith положении справа.

Кроме того, |= средства сделать сравнение битового "ИЛИ" и присвоить результат левой стороне выражения. Результат битового "ИЛИ" 1 для каждого бита, где соответствующая левая или правая сторона укусила, 1,

1) Символ является действительно просто 8-разрядным целым числом. '0' == 48, и все это, которое подразумевает.

2) (~ (указатель-> intX) и (1 <<i)), evalutates, указывает ли 'i'th бит (справа) в intX члене любого указателя на, не установлен. ~ инвертирует биты, таким образом, все 0s становятся 1 с и наоборот, затем 1 <<, я помещаю единственный 1 в желаемое местоположение, и комбинирую два значения так, чтобы только желаемый бит был сохранен, и все это evalutes к истинному, если тот бит был 0 для начала.

3) | является поразрядным или. Это берет каждый бит в обоих операндах и выполняет логическое ИЛИ, приводя к результату, где каждый бит установлен, если любой операнд имел тот набор битов. 0b11000000 | 0b00000011 == 0b11000011. | = оператор присваивания, таким же образом что + = b означает, что a=a+b, | = b означает a=a|b.

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

Одинарные кавычки используются, чтобы указать, что используется единственный символ. '0' поэтому символ '0', который имеет код ASCII 48. 3-'0' =3-48

'1 <<я' смещаюсь 1, я помещаю налево, поэтому только ith укусил, справа 1.
~pointer-> intX инвертирует поле intX, таким образом, логическое И возвращает истинное значение (не 0), когда intX имеет каждый бит за исключением бита ith, справа не установлен.

char a = '3';  
int x = a - '0';

у Вас была опечатка здесь (заметьте вокруг 3), это присваивает значение ASCII символа 3 к символьной переменной, затем следующая строка берет '3' - '0' и присваивает его x из-за способа, которым труд значений ASCII, x затем будет равен 3 (целочисленное значение)

В первом сравнении я никогда не видел, что ~ используется на указателе тот путь прежде, другая опечатка, возможно? Если я должен был считать следующий код:

(~pointer->intX & (1 << i))

Я сказал бы" (значение intX разыменованный от указателя), И (1 оставленный сместил меня времена)"

1 <<я - быстрый способ умножиться 1 питанием 2, т.е. если мне 3 года, затем 1 <<3 == 8

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

В 2-м сравнении x | = y совпадает с x = x | y

1. Я предполагаю, что Вы имеете в виду символ = '3'; для первой строки кода (иначе Вы получаете довольно странный ответ). Основной принципал - то, что коды ASCII для цифр последовательны, т.е. код для '0' =48, код для '1' =49, и так далее. Вычитание '0' просто преобразовывает от кода ASCII до фактической цифры, так например, '3' - '0' = 3, и так далее. Обратите внимание, что это будет только работать, если символ, из которого Вы вычитаете '0', будет фактической цифрой - иначе, то результат будет иметь мало значения.

2. a. Без контекста, "почему" из этого кода невозможно сказать. Что касается того, что это делает, кажется, что, если оператор оценивает как верный, когда бит i из указателя-> intX не установлен, т.е. что конкретный бит является 0. Я верю, и оператор выполняется перед ~ оператором, поскольку ~ оператор имеет очень низкий приоритет. Код мог лучше использовать круглые скобки для создания намеченного порядка из операций более ясным. В этом случае порядок операций не мог бы иметь значения, хотя - я полагаю, что результатом является то же так или иначе.

   b. Это просто создает число со всеми битами КРОМЕ бита, который я установил на 1. Удобный способ создать маску для бита я должен использовать выражение (1 <<i).

3. Операция битового "ИЛИ" в этом случае используется для установки битов, указанных СТРОКОЙ, постоянной к 1. Если эти биты не установлены, это устанавливает их; если они уже установлены, это не имеет никакого эффекта.

1) Кто-то может объяснить мне, как следующий код работает? обуглитесь = 3; интервал x = - '0'; я undertand, это сделано для преобразования символа в интервал, однако я не понимаю логику позади него. Почему/Как это работает?

Конечно. переменная символа типа, и путем помещения одинарных кавычек приблизительно 0, который заставляет C просматривать его как символ также. Наконец, целый оператор автоволшебно преобразован тип к его целочисленному эквиваленту, потому что x определяется как целое число.

2) Теперь, Относительно Побитовых операторов, я чувствую себя действительно потерянным здесь.---, Что делает этот код? если (~pointer-> intX и (1 <<i)) {C++; n = я;} я считал где-нибудь, что ~ инвертирует биты, но мне не удается видеть то, что делает этот оператор и почему это делающий это.

(~pointer->intX & (1 << i)) is saying:

инвертируйте intX, и И это с 1, смещенным оставленный мной биты

таким образом, что Вы получаете, если intX = 1011, и я = 2, приравнивается к

(0100 & 0100) 

-negate 1011 = 0100

-(1 << 2) = 0100

0100 & 0100 = 1 :)

затем, если операция И возвращает 1 (который в моем примере она делает) {C++; n = я;}

таким образом, инкремент c на 1, и переменная набора n, чтобы быть мной

То же с этой строкой: row.data = ~ (1 <<i);

Same principle here.
Shift a 1 to the left by i places, and negate.

So, if i = 2 again

(1 << 2) = 0100

~(0100) = 1011

**---Другой вопрос:

if (x != a) { ret |= ROW; }

Что exacly | = оператор, делающий? Из того, что я читал, | = ИЛИ но я не вполне понимаю то, что это выполнением оператора. **

если (x! = a) (надо надеяться, это очевидно для Вас...., если переменная x не равняется переменной a),

ret |= ROW;

equates to

ret = ret | ROW;

что означает, двоичный файл, ИЛИ мочите со СТРОКОЙ

Для примеров точно, что И и ИЛИ операции выполняют, у Вас должно быть достойное понимание бинарной логики.

Проверьте Википедию на таблицы истинности... т.е.

Битовые операции