imported>Mercury: /* {{якорь|dynamic_cast}} Операция {{cpp|dynamic_cast}} */

2026-02-02T01:22:20Z

{{якорь|dynamic_cast}} Операция {{cpp|dynamic_cast}}

Новая страница

'''Приведе́ние (преобразование) ти́па''' ({{lang-en|type conversion}}, {{lang-en2|typecasting}}) — в [[Информатика|информатике]] преобразование значения одного [[тип данных|типа]] в значение другого типа.

== Описание ==
Выделяют приведения типов:
* явные ({{lang-en|explicit}});
* неявные ({{lang-en|implicit}} ''cast, coercion'').

Явное приведение задаётся [[программист]]ом в тексте программы с помощью:
* конструкции языка;
* встроенных [[Функция (программирование)|функций]], принимающей значение одного типа и возвращающей значение другого типа.

Неявное приведение выполняется [[транслятор]]ом ([[компилятор]]ом или [[интерпретатор]]ом) по правилам, описанным в стандарте языка. Стандарты большинства языков запрещают неявные преобразования.

В [[Объектно-ориентированное программирование|объектно-ориентированных]] языках, таких как [[C++]], механизм [[наследование (программирование)|наследования]] реализуется посредством приведения типа указателя или ссылки на текущий объект к базовому классу (в [[типобезопасность|типобезопасных]], таких как [[OCaml]], понятие о приведении типов отсутствует принципиально, и допустимость обращения к компоненту подтипа контролируется механизмом [[Типобезопасность|проверки согласования типов]] на этапе компиляции, а в машинном коде остаётся прямое обращение).

== Неявное приведение типа ==

=== Неявное приведение типа в языках C/C++ ===
Неявное приведение типов происходит в следующих случаях<ref>cppreference.com. [http://en.cppreference.com/w/cpp/language/implicit_cast Implicit conversions] {{Wayback|url=http://en.cppreference.com/w/cpp/language/implicit_cast |date=20141218154009 }}.</ref>:
* после вычисления операндов бинарных арифметических, логических, битовых операций, операций сравнения, а также 2-го или 3-го операнда операции «?:»; значения операндов приводятся к одинаковому типу;
* перед выполнением присваивания;
* перед передачей аргумента функции;
* перед возвратом функцией возвращаемого значения;
* после вычисления выражения конструкции {{cpp|1=switch}} значение приводится к целочисленному типу;
* после вычисления выражений конструкций {{cpp|1=if}}, {{cpp|1=for}}, {{cpp|1=while}}, {{cpp|1=do}}-{{cpp|1=while}} значение приводится к типу {{cpp|1=bool}}.
Например, при выполнении бинарной арифметической операции значения операндов приводятся к одному типу. При наследовании указатели производного класса приводятся к указателям базового класса.

Рассмотрим пример на языке [[Си (язык программирования)|C]].

<source lang="c">
double d; // вещественный тип
long l; // целый тип
int i; // целый тип

if ( d > i ) d = i;
if ( i > l ) l = i;
if ( d == l ) d *= 2;
</source>

При выполнении операций сравнения и при присваивании переменные разных типов неявно приводятся к одному типу.

При неявных преобразованиях возможны побочные эффекты. Например, при приведении числа вещественного типа к целому типу дробная часть отсекается ([[округление]] не выполняется)<ref>open-std.org [http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2310.pdf ISO/IEC 9899:2018 C Programming Language Standard (C18)] {{Wayback|url=http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2310.pdf |date=20200722132012 }} 6.3.1.4 Real floating and integer.</ref>. При обратном преобразовании возможно понижение точности из-за различий в [[Число#Представление чисел в памяти компьютера|представлении]] вещественных и целочисленных чисел. Например, в переменной типа {{cpp|1=float}} ([[число с плавающей точкой]] [[Число одинарной точности|одинарной точности]] по стандарту [[IEEE 754]]), нельзя сохранить число {{formatnum:16777217}} без потери точности, а в 32-битной переменной целого типа {{cpp|1=int}} — можно. Из-за потери точности операции сравнения одного и того же числа, представленного целым и вещественным типами (например, {{cpp|1=int}} и {{cpp|1=float}}), могут давать ложные результаты (числа могут быть не равны).

<source lang="c">
#include <stdio.h>

int main ( void )
{
int i_value = 16777217;
float f_value = 16777216.0;
printf( "The integer is:%d\n", i_value );
printf( "The float is: %f\n", f_value );
printf( "Their equality:%d\n", i_value == f_value );
}
</source>

Приведённый код выведет следующее, если размер {{cpp|1=int}} — 32 бита и компилятор поддерживает стандарт [[IEEE 754]]:

<pre>
The integer is: 16777217
The float is: 16777216.000000
Their equality: 1
</pre>

== Явное приведение типа ==

=== Приведения типов в языке C ===
Для явного приведения типов имя типа указывается в круглых скобках перед переменной или выражением. Рассмотрим пример.

<source lang="c">
int X;
int Y = 200;
char C = 30;
X = (int)C * 10 + Y; // переменная С приводится к типу int
</source>

Для вычисления последнего выражения [[компилятор]] выполняет примерно следующие действия:
* сначала переменная {{cpp|1=C}} символьного типа {{cpp|1=char}} явно приводится к целочисленному типу {{cpp|1=int}} путём расширения [[Разрядность|разрядности]];
* выполняется вычисление операндов для операции умножения. Левый операнд имеет тип {{cpp|1=int}}. Правый операнд — константа <code>10</code>, а такие константы по умолчанию имеют тип {{cpp|1=int}}. Так как оба операнда оператора «<tt>*</tt>» имеют тип {{cpp|1=int}}, неявное приведение типов не выполняется. Результат умножения тоже имеет тип {{cpp|1=int}};
* выполняется вычисление операндов операции сложения. Левый операнд — результат умножения имеет тип {{cpp|1=int}}. Правый операнд — переменная {{cpp|1=Y}} имеет тип {{cpp|1=int}}. Так как оба операнда оператора «<tt>+</tt>» имеют тип {{cpp|1=int}}, неявное приведение к общему типу не выполняется. Результат сложения тоже имеет тип {{cpp|1=int}};
* выполнение присваивания. Левый операнд — переменная {{cpp|1=X}} имеет тип {{cpp|1=int}}. Правый операнд — результат вычисления выражения, записанного справа от знака «<tt>=</tt>», тоже имеет тип {{cpp|1=int}}. Так как оба операнда оператора «<tt>=</tt>» имеют одинаковый тип, неявное приведение типов не выполняется.

Но даже при этом возможны ошибки. Тип {{cpp|1=char}} может быть как знаковым ({{cpp|1=signed char}}), так и беззнаковым ({{cpp|1=unsigned char}}); результат зависит от реализации компилятора и такое поведение разрешено стандартом. Значение беззнакового типа {{cpp|1=char}} при преобразовании к знаковому типу {{cpp|1=int}} может оказаться отрицательным из-за особенностей реализации машинных инструкций на некоторых [[процессор]]ах. Чтобы избежать неоднозначностей, рекомендуется явно указывать знаковость для типа {{cpp|1=char}}.

=== Приведения типов в языке C++ ===
В языке [[C++]] существует пять операций для явного приведения типа. Первая операция — круглые скобки ({{cpp|1=(type_to)expression_from}}) поддерживается для сохранения совместимости с [[Си (язык программирования)|C]]. Остальные четыре операции записываются в виде

'''xxx_cast'''< type_to >( expression_from )

Рассмотрим пример.

<source lang="cpp">
y = static_cast< signed short >( 65534 ); // переменной y будет присвоено значение -2
</source>

Громоздкие [[зарезервированное слово|ключевые слова]] являются напоминанием программисту о том, что приведение типа чревато проблемами.

==== {{якорь|static_cast}} Операция {{cpp|static_cast}} ====
{{main|static_cast}}
Назначение: допустимые приведения типов.

Операция {{cpp|1=static_cast}} аналогична операции «круглые скобки» с одним исключением: она не выполняет приведение указателей на неродственные типы (для этого применяется операция {{cpp|1=reinterpret_cast}}).

Применение:
* преобразование между числовыми и enum, в том числе если неявное преобразование невозможно ({{cpp|int → enum class}}) или приводит к предупреждению «Возможная потеря точности» ({{cpp|double → float}});
* приведение указателей к типу {{cpp|1=void*}} и наоборот;
* приведение указателей на производные типы к указателям на базовые типы и наоборот;
* выбор одной из нескольких [[перегрузка функций|перегруженных функций]];
<source lang="cpp">
bool myLess(const wchar_t*, const wchar_t*);
bool myLess(const std::wstring&, const std::wstring&);

std::vector<std::wstring> list;
std::sort(list.begin(), list.end(), static_cast<bool(*)(const std::wstring&, const std::wstring&)>(myLess));
</source>
* явный вызов конструктора с одним аргументом или перегруженной операции приведения типа;
<source lang="cpp">
struct Type {
// конструктор с одним аргументом для приведения типа int к типу Type
Type ( int );

// перегруженная операция для приведения типа Type к типу double
operator double () const;
};

int main () {
Type x, y;
int i;
double d;

// вызов конструктора с одним аргументом
x = y + static_cast< Type >( i );

// вызов перегруженной операции приведения типа
d = static_cast< double >( x );

return 0;
}
</source>
: конструктор может иметь большее число аргументов, но для них должны быть заданы значения по умолчанию;
<source lang="cpp">
struct Type {
// конструктор с несколькими аргументами для приведения типа int к типу Type;
// для 2-го и последующих аргументов заданы значения по умолчанию
Type ( int, int = 10, float = 0.0 );
};
</source>

* приведение типа в [[шаблоны C++|шаблонах]] (компилятор уже при специализации шаблона решает, какие операции использовать);
* приведение операндов [[Тернарная условная операция|тернарной условной операции]] «<code>?:</code>» к одному типу (значения 2-го и 3-го операндов должны иметь одинаковый тип);

Ограничения на <code>expression_from</code>: нет.

Ограничения на <code>type_to</code>: должен существовать способ преобразования значения выражения <code>expression_from</code> к типу <code>type_to</code>, с помощью <code>operator type_to</code> или конструктора.

Производит ли операция {{cpp|1=static_cast}} код: в общем случае да (например, вызов перегруженной операции приведения типа или конструктора).

Источники логических ошибок: зависят от того, что собираетесь делать операцией. Возможны переполнения, выход за диапазон и даже (для преобразования указателей) порча памяти.

Пути избавления: зависят от задачи, и часто избавляться не нужно.

Примеры.

<source lang="cpp">
// Получить процент попаданий.
double hitpercent (
const int aHitCount, // число попаданий
const int aShotCount // число выстрелов
) {
if ( aShotCount == 0 ) return 0.0;
// Приведение типов к double выполняется для выполнения вещественного (не целочисленного) деления
return static_cast< double >( aHitCount * 100 ) / static_cast< double >( aShotCount );
}

// следующие строчки эквивалентны

// использование операции static_cast
string s = static_cast< string >( "Hello!" );
// вызов конструктора с одним аргументом
string s = string( "Hello!" );
// использование операции «круглые скобки»
string s = (string) "Hello!";

string s = static_cast< string >( 5 ); // не компилируется, компилятор не может найти подходящий конструктор
</source>

==== {{якорь|dynamic_cast}} Операция {{cpp|dynamic_cast}} ====
{{main|Dynamic_cast}}
Назначение: приведение вниз по иерархии наследования, с особым поведением, если объект не имеет нужного типа. Используется именно в случаях, когда программист не уверен в типе.

Операция получает информацию о типе объекта <code>expression_from</code> с помощью [[RTTI]]. Если тип будет <code>type_to</code> или его подтипом, приведение выполняется. Иначе:
* для указателей возвращается [[NULL (Си)|NULL]];
* для ссылок создаётся [[обработка исключений|исключение]] {{cpp|1=std::bad_cast}}.

Ограничения на <code>expression_from</code>: выражение должно быть ссылкой или указателем на объект, имеющий хотя бы одну [[виртуальный метод|виртуальную функцию]].

Ограничения на <code>type_to</code>: любой другой виртуальный, также соответственно ссылка или указатель.

Производит ли операция {{cpp|1=dynamic_cast}} код: да.

Логические ошибки возможны, если операции передать аргумент, не имеющий тип <code>type_to</code>, и не проверить указатель на равенство {{cpp|1=NULL}} (соответственно не обработать исключение {{cpp|1=std::bad_cast}}).

Пути избавления: продуманная объектная система. Иногда (например, в обработке событий пользовательского интерфейса) dynamic_cast используют только как дополнительную самопроверку, когда и без того известно, какого типа объект, спровоцировавший событие.

==== {{якорь|const_cast}} Операция {{cpp|const_cast}} ====
Назначение: снятие/установка модификатора(ов) {{cpp|1=const}}, {{cpp|1=volatile}} и/или {{cpp|1=mutable}}. Часто это применяется, чтобы обойти неудачную архитектуру программы или библиотеки, для стыковки с другими языками, для передачи информации через обобщённые указатели <code>void*</code>, для одновременного написания const- и не-const-версии функции<ref name="weekly">{{Cite web |url=https://www.youtube.com/watch?v=iuLwHoMFP_Y |title=C++ Weekly - Ep 283 - Stop Using const_cast! - YouTube |access-date=2021-08-20 |archive-date=2021-08-20 |archive-url=https://web.archive.org/web/20210820190607/https://www.youtube.com/watch?v=iuLwHoMFP_Y |url-status=live }}</ref>

Ограничения на <code>expression_from</code>: выражение должно возвращать ссылку или указатель.

Ограничения на <code>type_to</code>: тип <code>type_to</code> должен совпадать с типом выражения <code>expression_from</code> с точностью до модификатора(ов) {{cpp|1=const}}, {{cpp|1=volatile}} и {{cpp|1=mutable}} .

Производит ли операция {{cpp|1=const_cast}} код: нет.

Источники логических ошибок: программа может изменить неизменяемый объект. Иногда это может привести к [[SIGSEGV|ошибке сегментации]], иногда подпрограмма может не ожидать<ref name="weekly" />, что память, которую она предоставила для чтения, вдруг изменили.

Пути избавления: просчитанная const-корректность и удачный API: с Си++17 {{cpp|string.data()}} получила версию без const. С [[Си++14]] — общая шаблонная функция, возвращающая {{cpp|decltype(auto)}}, и функции с const и без вызывают её<ref name="weekly" />. С [[Си++23]] эту функцию сразу можно использовать как метод.

Для примера рассмотрим код [[Библиотека (программирование)#Динамические библиотеки|динамической библиотеки]].

<source lang="cpp">
#include <string> // string
using namespace std;

namespace
{
string s = "Wikipedia"; // Глобальная переменная
// метод string::c_str() возвращает указатель типа const char *
}

typedef char * PChar;

void __declspec( dllexport ) WINAPI SomeDllFunction ( PChar & rMessage )
{
// преобразование char const * в char *
rMessage = const_cast< char * >( s.c_str() );
}
</source>

При загрузке библиотеки в память [[Процесс (информатика)|процесса]] создаёт новый сегмент данных, в котором размещаются глобальные переменные.
Код функции {{cpp|1=SomeDllFunction()}} находится в библиотеке и при вызове возвращает указатель на строковые данные. Операция {{cpp|1=const_cast}} используется для удаления модификатора {{cpp|1=const}}.

==== {{якорь|reinterpret_cast}} Операция {{cpp|reinterpret_cast}} ====
Назначение: [[каламбур типизации]] — назначение ячейке памяти другого типа (не обязательно совместимого с данным) с сохранением битового представления.

Объект, возвращаемый выражением <code>expression_from</code>, рассматривается как объект типа <code>type_to</code>.

Ограничения на <code>expression_from</code>: выражение должно возвращать значение порядкового типа (любой из целых, логический {{cpp|1=bool}} или перечислимый {{cpp|1=enum}}), указатель или ссылку.

Ограничения на <code>type_to</code>:
* Если <code>expression_from</code> возвращает значение порядкового типа или указатель, тип <code>type_to</code> может быть порядковым типом или указателем.
* Если <code>expression_from</code> возвращает ссылку, тип <code>type_to</code> должен быть ссылкой.

Производит ли операция {{cpp|1=reinterpret_cast}} код: нет.

Источники логических ошибок. Объект, возвращаемый выражением <code>expression_from</code>, может не иметь типа <code>type_to</code>. Нет никакой возможности проверить это, всю ответственность за корректность преобразования программист берёт на себя.

Пути избавления: поскольку функция предназначена для работы на низком уровне и обхода ошибок чужой архитектуры, практически нет. Одну из задач — низкоуровневую работу с битами и байтами памяти — можно и нужно заменять на функцию {{cpp|bit_cast}} Си++20.

Рассмотрим примеры.

<source lang="cpp">
// Возвращает true, если число x конечное.
// Возвращает false, если число x равно ∞ или NaN.
bool isfinite ( double const x )
{

// преобразование double const -> uint64_t const &
uint64_t const & y = reinterpret_cast< uint64_t const & >( x );

return ( ( y & UINT64_C( 0x7FF0000000000000 ) ) != UINT64_C( 0x7FF0000000000000 ) );
}

// попытка получения адреса временного значения
long const & y = reinterpret_cast< long const & >( x + 5.0 );
// ошибка: выражение x + 5.0 не является ссылкой
</source>

== См. также ==
* [[Dynamic cast]]
* [[Динамическая идентификация типа данных]] (RTTI)
* [[Типизация данных]]
* [[Каламбур типизации]]

== Примечания ==
{{Примечания}}

== Ссылки ==
* Robert C. Seacord [https://web.archive.org/web/20140921015632/https://www.securecoding.cert.org/confluence/display/seccode/INT02-C.+Understand+integer+conversion+rules ПINT02-C. Understand integer conversion rules]{{ref|en}}, cert.org

{{нет источников|дата=2015-01-03}}
{{перевести|en|Type conversion}}

[[Категория:Типы данных]]
[[Категория:Концепции языков программирования]]
[[Категория:Статьи с примерами кода C++]]
[[Категория:Операции в программировании]]

Приведение типа - История изменений

imported>Mercury: /* {{якорь|dynamic_cast}} Операция {{cpp|dynamic_cast}} */