3.2.4 Поразрядные логические операции

Поразрядные логические операции

& | ^ ~ >> <<

применяются к целым, то есть к объектам типа char, short, int, long и

к их беззнаковым аналогам. Результат операции также будет целым.

Чаще всего поразрядные логические операции используются для

работы с небольшим по величине множеством данных (массивом разрядов).

В этом случае каждый разряд беззнакового целого представляет один

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

Бинарная операция & интерпретируется как пересечение множеств,

операция | как объединение, а операция ^ как разность множеств.

С помощью перечисления можно задать имена элементам множества.

Ниже приведен пример, заимствованный из <iostream.h>:

class ios {

public:

enum io_state {

goodbit=0, eofbit=1, failbit=2, badbit=4

};

// ...

};

Состояние потока можно установить следующим присваиванием:

cout.state = ios::goodbit;

Уточнение именем ios необходимо, потому что определение io_state находится

в классе ios, а также чтобы не возникло коллизий, если пользователь заведет свои

имена наподобие goodbit.

Проверку на корректность потока и успешное окончание операции можно

задать так:

if (cout.state&(ios::badbit|ios::failbit)) // ошибка в потоке

Еще одни скобки необходимы потому, что операция & имеет более высокий

приоритет, чем операция "|".

Функция, обнаружившая конец входного потока, может сообщать об этом так:

cin.state |= ios::eofbit;

Операция |= используется потому, что в потоке уже могла быть ошибка

(т.е. state==ios::badbit), и присваивание

cin.state =ios::eofbit;

могло бы затереть ее признак. Установить отличия в состоянии двух

потоков можно следующим способом:

ios::io_state diff = cin.state^cout.state;

Для таких типов, как io_state, нахождение различий не слишком полезная

операция, но для других сходных типов она может оказаться весьма

полезной. Например, полезно сравнение двух разрядных массива, один из

которых представляет набор всех возможных обрабатываемых прерываний,

а другой - набор прерываний, ожидающих обработки.

Отметим, что использование полей ($$R.9.6) может служить удобным

и более лаконичным способом работы с частями слова, чем сдвиги и

маскирование. С частями слова можно работать и с помощью поразрядных

логических операций. Например, можно выделить средние 16 разрядов

из средины 32-разрядного целого:

unsigned short middle(int a) { return (a>>8)&0xffff; }

Только не путайте поразрядные логические операции с просто логическими

операциями:

&& || !

Результатом последних может быть 0 или 1, и они в основном

используются в условных выражениях операторов if, while или for

($$3.3.1). Например, !0 (не нуль) имеет значение 1, тогда как ~0

(дополнение нуля) представляет собой набор разрядов "все единицы",

который обычно является значением -1 в дополнительном коде.

3.2.5 Преобразование типа

Иногда бывает необходимо явно преобразовать значение одного типа в

значение другого. Результатом явного преобразования будет

значение указанного типа, полученное из значения другого типа.

Например:

float r = float(1);

Здесь перед присваиванием целое значение 1 преобразуется в значение

с плавающей точкой 1.0f. Результат преобразования типа не является

адресом, поэтому ему присваивать нельзя (если только тип не является

ссылкой).

Существуют два вида записи явного преобразования типа:

традиционная запись, как операция приведения в С, например, (double)a

и функциональная запись, например, double(a). Функциональную запись

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

Например, чтобы преобразовать значение в тип указателя, надо или

использовать приведение

char* p = (char*)0777;

или определить новое имя типа:

typedef char* Pchar;

char* p = Pchar(0777);

По мнению автора, функциональная запись в нетривиальных случаях

предпочтительнее. Рассмотрим два эквивалентных примера:

Pname n2 = Pbase(n1->tp)->b_name; // функциональная запись

Pname n3 = ((Pbase)n2->tp)->b_name; // запись с приведением

Поскольку операция -> имеет больший приоритет, чем операция приведения,

последнее выражение выполняется так:

((Pbase)(n2->tp))->b_name

Используя явное преобразование в тип указателя можно выдать данный объект

за объект произвольного типа. Например, присваивание

any_type* p = (any_type*)&some_object;

позволит обращаться к некоторому объекту (some_object) через указатель

p как к объекту произвольного типа (any_type). Тем не менее, если

some_object в действительности имеет тип не any_type, могут получиться

странные и нежелательные результаты.

Если преобразование типа не является необходимым, его вообще следует

избегать. Программы, в которых есть такие преобразования, обычно

труднее понимать, чем программы, их не имеющие. В то же время

программы с явно заданными преобразованиями типа понятнее,

чем программы, которые обходятся без таких преобразований, потому что

не вводят типов для представления понятий более высокого уровня.

Так, например, поступают программы, управляющие регистром устройства с

помощью сдвига и маскирования целых, вместо того, чтобы определить

подходящую структуру (struct) и работать непосредственно с ней

(см. $$2.6.1). Корректность явного преобразования типа часто

существенно зависит от того, насколько программист понимает, как язык

работает с объектами различных типов, и какова специфика данной реализации

языка. Приведем пример:

int i = 1;

char* pc = "asdf";

int* pi = &i;

i = (int)pc;

pc = (char*)i; // осторожно: значение pc может измениться.

// На некоторых машинах sizeof(int)

// меньше, чем sizeof(char*)

pi = (int*)pc;

pc = (char*)pi; // осторожно: pc может измениться

// На некоторых машинах char* имеет не такое

// представление, как int*

Для многих машин эти присваивания ничем не грозят, но для некоторых

результат может быть плачевным. В лучшем случае подобная программа

будет переносимой. Обычно без особого риска можно предположить,

что указатели на различные структуры имеют одинаковое представление.

Далее, произвольный указатель можно присвоить (без явного преобразования

типа) указателю типа void*, а void* может быть явно преобразован

обратно в указатель произвольного типа.

В языке С++ явные преобразования типа оказывается излишними во многих

случаях, когда в С (и других языках) они требуются. Во многих

программах можно вообще обойтись без явных преобразований типа, а во

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