4.11.3. Явные преобразования

Иногда необходимо явно преобразовать объект в другой тип. Например, в следующем коде может понадобиться использование деления с плавающей точкой:

int i, j;

double slope = i/j;

Для этого необходим способ явного преобразования переменных i и/или j в тип double. Для явного преобразования используется приведение (cast) типов.

Именованные операторы приведения

Именованный оператор приведения имеет следующую форму:

имя_приведения<тип>(выражение);

где тип — это результирующий тип преобразования, а выражение — приводимое значение. Если тип — ссылка, то результат l-значение. Имя_приведения может быть одним из следующих: static_cast, dynamic_cast, const_cast и reinterpret_cast. Приведение dynamic_cast, обеспечивающее идентификацию типов времени выполнения, рассматривается в разделе 19.2. Имя_приведения определяет, какое преобразование осуществляется.

Оператор static_cast

Любое стандартное преобразование типов, кроме задействующего спецификатор 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 — в другом.

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

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

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

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

В зависимости от используемых типов, приведение старого стиля срабатывает аналогично операторам 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);