Язык программирования C++. Пятое издание - Стенли Липпман

Любое стандартное преобразование типов, кроме задействующего спецификатор const нижнего уровня, можно затребовать, используя оператор static_cast. Например, приведя тип одного из операндов к типу double, можно заставить выражение использовать деление с плавающей точкой:

// приведение для вынужденного деления с плавающей точкой

double slope = static_cast<double>(j) / i;

Оператор static_cast зачастую полезен при присвоении значения большего арифметического типа переменной меньшего. Приведение сообщает и читателю программы, и компилятору, что мы знаем и не беспокоимся о возможной потере точности. При присвоении большего арифметического типа меньшему компиляторы зачастую выдают предупреждение. При явном приведении предупреждающее сообщение не выдается.

Оператор static_cast полезен также при выполнении преобразований, которые компилятор не выполняет автоматически. Например, его можно использовать для получения значения указателя, сохраняемого в указателе void* (см. раздел 2.3.2):

void* p = &d; // ok: адрес любого неконстантного объекта может

              // храниться в указателе void*

// ok: преобразование void* назад в исходный тип указателя

double *dp = static_cast<double*>(p);

После сохранения адреса в указателе типа void* можно впоследствии использовать оператор static_cast и привести указатель к его исходному типу, что позволит сохранить значение указателя. Таким образом, результат приведения будет равен первоначальному значению адреса. Однако следует быть абсолютно уверенным в том, что тип, к которому приводится указатель, является фактическим типом этого указателя; при несоответствии типов результат непредсказуем.

Оператор const_cast

Оператор const_cast изменяет только спецификатор const нижнего уровня своего операнда (см. раздел 2.4.3):

const char *pc;

char *p = const_cast<char*>(pc); // ok: однако запись при помощи p

                                 // указателя непредсказуема

Принято говорить, что приведение, преобразующее константный объект в неконстантный, "сбрасывает const". При сбросе константности объекта компилятор больше не будет препятствовать записи в этот объект. Если объект первоначально не был константным, использование приведения для доступа на запись вполне допустимо. Но применение оператора const_cast для записи в первоначально константный объект непредсказуемо.

Только оператор const_cast позволяет изменить константность выражения. Попытка изменить константность выражения при помощи любого другого именованного оператора приведения закончится ошибкой компиляции. Аналогично нельзя использовать оператор const_cast для изменения типа выражения:

const char *cp;

// ошибка: static_cast не может сбросить const

char *q = static_cast<char*>(cp);

static_cast<string>(cp); // ok: преобразует строковый литерал в строку

const_cast<string>(cp);  // ошибка: const_cast изменяет только

                         // константность

Оператор const_cast особенно полезен в контексте перегруженных функций, рассматриваемых в разделе 6.4.

Оператор reinterpret_cast

Оператор reinterpret_cast осуществляет низкоуровневую интерпретацию битовой схемы своих операндов. Рассмотрим, например, следующее приведение:

int *ip;

char *pc = reinterpret_cast<char*>(ip);

Никогда не следует забывать, что фактическим объектом, на который указывает указатель pc, является целое число, а не символ. Любое использование указателя pc, подразумевающее, что это обычный символьный указатель, вероятно, потерпит неудачу во время выполнения. Например, следующий код, вероятней всего, приведет к непредвиденному поведению во время выполнения:

string str(pc);

Использование указателя pc для инициализации объекта типа string — хороший пример небезопасности оператора reinterpret_cast. Проблема в том, что при изменении типа компилятор не выдаст никаких предупреждений или сообщений об ошибке. При инициализации указателя pc адресом типа int компилятор не выдаст ни предупреждения, ни сообщения об ошибке, поскольку явно указано, что это и нужно. Однако любое последующее применение указателя pc подразумевает, что он содержит адрес значения типа char*. Компилятор не способен выяснить, что фактически это указатель на тип int. Таким образом, инициализация строки str при помощи указателя pc вполне правомерна, хотя в данном случае абсолютно бессмысленна, если не хуже! Отследить причину такой проблемы иногда чрезвычайно трудно, особенно если приведение указателя ip к pc происходит в одном файле, а использование указателя pc для инициализации объекта класса string — в другом.

Оператор reinterpret_cast жестко зависит от конкретной машины. Чтобы безопасно использовать оператор reinterpret_cast, следует хорошо понимать, как именно реализованы используемые типы, а также то, как компилятор осуществляет приведение.

Приведение типов в старом стиле

В ранних версиях языка С++ явное приведение имело одну из следующих двух форм:

тип (выражение); // форма записи приведения в стиле функции

(тип) выражение; // форма записи приведения в стиле языка С

В зависимости от используемых типов, приведение старого стиля срабатывает аналогично операторам const_cast, static_cast или reinterpret_cast. В случаях, где используются операторы static_cast или const_cast, приведение типов в старом стиле позволяет осуществить аналогичное преобразование, что и соответствующий именованный оператор приведения. Но если ни один из подходов не допустим, то приведение старого стиля срабатывает аналогично оператору reinterpret_cast. Например, используя форму записи старого стиля, можно получить тот же результат, что и с использованием reinterpret_cast.

char *pc = (char*) ip; // ip указатель на тип int

Совет. Избегайте приведения типов

Приведение нарушает обычный порядок контроля соответствия типов (см. раздел 2.2), поэтому авторы настоятельно рекомендуют избегать приведения типов. Это особенно справедливо для оператора reinterpret_cast. Такие приведения всегда опасны. Операторы const_cast могут быть весьма полезны в контексте перегруженных функций, рассматриваемых в разделе 6.4. Использование оператора const_cast зачастую свидетельствует о плохом проекте. Другие операторы приведения, static_cast и dynamic_cast, должны быть необходимы нечасто. При каждом применении приведения имеет смысл хорошо подумать, а нельзя ли получить тот же результат другим способом. Если приведение все же неизбежно, имеет смысл принять меры, позволяющие снизить вероятность возникновения ошибки, т.е. ограничить область видимости, в которой используется приведенное значение, а также хорошо документировать все подобные случаи.

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

Упражнения раздела 4.11.3

Упражнение 4.36. С учетом того, что i имеет тип int, a d — double, напишите выражение i *= d так, чтобы осуществлялось целочисленное умножение, а не с плавающей запятой.

Упражнение 4.37. Перепишите каждое из следующих приведений старого стиля так, чтобы использовался именованный оператор приведения.

int i; double d; const string *ps; char *pc; void *pv;

(a) pv = (void*)ps; (b) i = int(*pc);

(c) pv = &d;        (d) pc = (char*)pv;

Упражнение 4.38. Объясните следующее выражение:

double slope = static_cast<double>(j/i);

4.12. Таблица приоритетов операторов

Таблица 4.4. Приоритет операторов

Порядок и оператор Действие Применение Раздел Л :: Глобальная область видимости ::имя 7.4.1   Л :: Область видимости класса класс::имя 3.2.2 Л :: Область видимости пространства имен пространствоимен::имя 3.1 Л . Обращение к члену класса объект.член 1.5.2   Л -> Обращение к члену класса pointer->член 3.4.1 Л [] Индексирование выражение[выражение] 3.5.2 Л () Вызов функции имя(список_выражений) 1.5.2 Л () Конструкция type тип(список_выражений) 4.11.3 П ++ Постфиксный инкремент l-значение++ 4.5   П -- Постфиксный декремент l-значение-- 4.5 П typeid Идентификатор типа typeid(тип) 19.2.2 П typeid Идентификатор типа времени выполнения typeid(выражение) 19.2.2 П Явное приведение Преобразование типов cast_имя<тип>(выражение) 4.11.3 П ++ Префиксный инкремент ++l-значение 4.5   П -- Префиксный декремент --l-значение 4.5 П ~ Побитовое NOT ~выражение 4.8 П ! Логическое NOT !выражение 4.3 П - Унарный минус -выражение 4.2 П + Унарный плюс +выражение 4.2 П * Обращение к значению *выражение 2.3.2 П & Обращение к адресу &l-значение 2.3.2 П () Преобразование типов (тип)выражение 4.11.3 П sizeof Размер объекта sizeof выражение 4.9 П sizeof Размер типа sizeof(тип) 4.9 П sizeof... Размер пакета параметров sizeof...(имя) 16.4 П new Создание объекта new тип 12.1.2 П new[] Создание массива new тип[размер] 12.1.2 П delete Освобождение объекта delete выражение 12.1.2 П delete[] Освобождение массива delete[] выражение 12.1.2 П noexcept Способность к передаче noexcept(выражение) 18.1.4 Л ->* Указатель на член класса указатель->*указатель_на_член 19.4.1   Л .* Указатель на член класса объект.*указатель_на_член 19.4.1 Л * Умножение выражение * выражение 4.2   Л / Деление выражение / выражение 4.2 Л % Деление по модулю (остаток) выражение % выражение 4.2 Л + Сумма выражение + выражение 4.2   Л - Разница выражение - выражение 4.2 Л << Побитовый сдвиг влево выражение << выражение 4.8   Л >> Побитовый сдвиг вправо выражение >> выражение 4.8 Л < Меньше выражение < выражение 4.3   Л <= Меньше или равно выражение <= выражение 4.3 Л > Больше выражение > выражение 4.3 Л >= Больше или равно выражение >= выражение 4.3 Л == Равенство выражение == выражение 4.3   Л != Неравенство выражение != выражение 4.3 Л & Побитовый AND выражение & выражение 4.8 Л ^ Побитовый XOR выражение ^ выражение 4.8 Л | Побитовый OR выражение | выражение 4.8 Л && Логический AND выражение && выражение 4.3 Л || Логический OR выражение || выражение 4.3 П ?: Условный оператор выражение ? выражение : выражение 4.7 П = Присвоение l-значение = выражение 4.4   П *=, /=, %=, Составные операторы присвоения l-значение += выражение, и т.д. 4.4  П +=, -=,  4.4 П <<=, >>=, 4.4 П &=, |=, ^=  4.4 П throw Передача исключения throw выражение 4.6.1 Л , Запятая выражение, выражение 4.10

Резюме