Reinterpret cast c что это
Приведение (C++/CX)
Windows Среда выполнения является абстракцией по сравнению с COM, в которой вместо исключений используются коды ошибок HRESULT. Как правило, Platform::InvalidCastException указывает на низкоуровневую ошибку E_NOINTERFACE модели COM.
static_cast
static_cast Проверяется во время компиляции, чтобы определить, существует ли отношение наследования между двумя типами. Приведение вызывает ошибку компилятора, если типы не связаны.
Объект в static_cast классе ссылки также приводит к выполнению проверки во время выполнения. Объект в static_cast классе ссылки может передавать проверку времени компиляции, но по-прежнему завершается сбоем во время выполнения; в данном случае Platform::InvalidCastException создается исключение. В общем случае не следует обрабатывать эти исключения, поскольку они почти всегда указывают на ошибки программирования, которые можно устранить на этапах разработки и тестирования.
safe_cast
Используйте safe_cast, если в коде не объявлена связь, но вы уверены, что приведение должно работать.
dynamic_cast
Другим применением dynamic_cast является Object^ Проверка, чтобы определить, содержит ли он тип упакованного значения. В этом случае вы пытаетесь применить dynamic_cast
dynamic_cast и отслеживание ссылок (%)
reinterpret_cast
Если вы используете reinterpret_cast для преобразования из интерфейса среды выполнения оневиндовс в другой, объект будет освобожден дважды. Поэтому используйте это приведение только при преобразовании в интерфейс расширений компонентов, не относящийся к C + +.
Типы ABI
класс среды выполнения среда выполнения Windows всегда должен быть преобразован в IInspectable* или в его интерфейс по умолчанию, если он известен.
Урок №56. Явное преобразование (приведение) типов данных
Обновл. 27 Окт 2021 |
Из предыдущего урока мы уже знаем, что компилятор в определенных случаях выполняет неявное преобразование типов данных. На этом уроке мы рассмотрим использование явной конвертации типов данных.
Зачем использовать явную конвертацию данных?
Когда вы хотите изменить один тип данных на другой, более крупный (по размеру/диапазону), то неявное преобразование является хорошим вариантом.
В случае, когда вы используете литералы (такие как 11 или 3 ), замена одного или обоих целочисленных литералов значением типа с плавающей точкой ( 11.0 или 3.0 ) приведет к конвертации обоих операндов в значения типа с плавающей точкой и выполнится деление типа с плавающей точкой.
Но что будет, если использовать переменные? Например:
Операторы явного преобразования типов данных
В языке C++ есть 5 видов операций явного преобразования типов:
конвертация C-style;
применение оператора static_cast;
применение оператора const_cast;
применение оператора dynamic_cast;
применение оператора reinterpret_cast.
На этом уроке мы рассмотрим конвертацию C-style и оператор static_cast. Оператор dynamic_cast мы будем рассматривать, когда дойдем до указателей и наследования. Применения операторов const_cast и reinterpret_cast следует избегать, так как они полезны только в редких случаях и могут создать немало проблем, если их использовать неправильно.
Правило: Избегайте использования операторов const_cast и reinterpret_cast, если у вас нет на это веских причин.
Конвертация C-style
В программе, приведенной выше, мы используем круглые скобки, чтобы сообщить компилятору о необходимости преобразования переменной i1 (типа int) в тип float. Поскольку переменная i1 станет типа float, то i2 также затем автоматически преобразуется в тип float, и выполнится деление типа с плавающей точкой!
Язык C++ также позволяет использовать этот оператор следующим образом:
Конвертация C-style не проверяется компилятором во время компиляции, поэтому она может быть неправильно использована, например, при конвертации типов const или изменении типов данных, без учета их диапазонов (что может привести к переполнению).
Следовательно, конвертацию C-style лучше не использовать.
Правило: Не используйте конвертацию C-style.
Оператор static_cast
В языке C++ есть еще один оператор явного преобразования типов данных — оператор static_cast. Ранее, на уроке о символьном типе данных char, мы уже использовали оператор static_cast для конвертации переменной типа char в тип int, выводя вместо символа целое число:
Оператор static_cast лучше всего использовать для конвертации одного фундаментального типа данных в другой:
Основным преимуществом оператора static_cast является проверка его выполнения компилятором во время компиляции, что усложняет возможность возникновения непреднамеренных проблем.
Использование операторов явного преобразования в неявном преобразовании
Если вы будете выполнять небезопасные неявные преобразования типов данных, то компилятор будет жаловаться. Например:
Конвертация переменной типа int (4 байта) в тип char (1 байт) потенциально опасна — компилятор выдаст предупреждение. Чтобы сообщить ему, что вы намеренно делаете что-то, что потенциально опасно (но хотите сделать это в любом случае), используйте оператор static_cast:
В следующем случае компилятор будет жаловаться, что конвертация из типа double в тип int может привести к потере данных:
Чтобы сообщить компилятору, что мы сознательно хотим сделать это:
Заключение
Преобразования типов данных следует избегать, если это вообще возможно, поскольку всякий раз, когда выполняется подобное изменение, есть вероятность возникновения непредвиденных проблем. Но очень часто случаются ситуации, когда этого не избежать. Поэтому в таких случаях лучше использовать оператор static_cast вместо конвертации C-style.
В чём разница между явным и неявным преобразованием типов данных?
Ответ
Неявное преобразование происходит, когда компилятор ожидает значение одного типа, но получает значение другого типа.
Явное преобразование происходит, когда программист использует оператор явного преобразования для конвертации значения из одного типа данных в другой.
Поделиться в социальных сетях:
Урок №55. Неявное преобразование типов данных
Комментариев: 14
Вот так нужно использовать конвертацию C-style
…
Правило: Не используйте конвертацию C-style.
)))))
Вон там лежит граната… Но ты её не трогай))
В VS 2019 static_cast == C-style. Компілятором не провіряється я пробував.
Решил просто попробовать, а оно работает.Код ниже выведет 8-битное число в двоичной системе. Не совсем понимаю, bitset о котором говорилось в уроке 46 — это тоже тип данных? Если же нет, то было бы интересно узнать как и почему это работает и что еще можно использовать с оператором static_cast.
Эдуард, это же аутентичная (для ПК) форма хранения данных!
прошло без всяких проблем.
Смотря что Вы подразумеваете под проблемой)
Если под проблемой Вы подразумеваете ошибку компиляции или рантайма, то да, код корректен и должен отработать, так что не удивительно, что оно «прошло без всяких проблем», однако, в действительности, проблема есть. Вам повезло со значениями и 90 делится на 3.6 без остатка, потому имеем 25, но подели Вы 90 на 3.7 (24.32…) или 3.5 (25.71…), или ещё на какое число, данный код выдаст Вам, для 3.7 (24), а для 3.5 (25), хотя остаток есть.
Во второй строке Вы неявно приводите i к типу double при делении, за счёт дробного знаменателя, получаете вещественный результат (по сути, временный rvalue объект, с типом double), который, затем, пытаетесь присвоить переменной, тип которой как был int, так и остался, а, значит, будет произведено приведение вещественного результата к типу int.
Если Вы так и хотели — работать с целочисленным значением, то всё хорошо, в противном же случае стоит сменить тип i, либо, если по какой то причине этого делать не хочется, создать буфер, который будет хранить вещественный результат.
Также, Вашу вторую строчку можно сократить до i /= 3.6;
пользоваться фокусом с числовыми литералами (11.0 / 3.0 или a / 2.0) также крайне не желательно. При некоторых настройках оптимизации такое деление все равно будет произведено в целых числах
В статье же все есть :)))
Часто пользуются фокусом для вещественного деления:
Приведение типов
Будучи на конференции Qt Developer Days 2010 я узнал, что одним из самых популярных вопросов на собеседовании в разные зарубежные компании, работающие с Qt библиотекой, является вопрос о различиях в способах приведения типов в C++. Поэтому здесь я рассмотрю основные различия между static_cast, dynamic_cast, const_cast, reinterpret_cast, C-style cast, qobject_cast и qvariant_cast
static_cast преобразует выражения одного статического типа в объекты и значения другого статического типа. Поддерживается преобразование численных типов, указателей и ссылок по иерархии наследования как вверх, так и вниз. Проверка производится на уровне компиляции, так что в случае ошибки сообщение будет получено в момент сборки приложения или библиотеки.
Используется для динамического приведения типов во время выполнения. В случае неправильного приведения типов для ссылок вызывается исключительная ситуация std::bad_cast, а для указателей будет возвращен 0. Использует систему RTTI (Runtime Type Information). Безопасное приведение типов по иерархии наследования, в том числе для виртуального наследования.
Пожалуй самое простое приведение типов. Снимает cv qualifiers — const и volatile, то есть константность и отказ от оптимизации компилятором переменной. Это преобразование проверяется на уровне компиляции и в случае ошибки приведения типов будет выдано сообщение.
Приведение типов без проверки. reinterpret_cast — непосредственное указание компилятору. Применяется только в случае полной уверенности программиста в собственных действиях. Не снимает константность и volatile. применяется для приведения указателя к указателю, указателя к целому и наоборот.
Си-шный метод приведения типов. Пожалуй самый нежелательный способ приведения типов. Страуструп пишет:
«Например, что это значит выражение — x = (T)y;. Мы не знаем. Это зависит от типа T, типов x и y. T может быть названием типа, typedef или может быть параметр template-а. Может быть, х и у являются скалярными переменными и Т представляет собой значение преобразования. Может быть, х объекта класса, производного от класса Y и Т — нисходящее преобразование. По этой причине программист может не знать, что он делает на самом деле.»
Вторая причина нежелательного использования приведения типов в C-style — трудоемкость процесса поиска мест приведения типов.
Приводит объект QObject* к типу TYPE если объект типа объекта TYPE или тип наследует от TYPE иначе возвращает 0. qobject_cast от 0 также дает 0. Необходимое условие. Класс должен наследовать от QObject и содержать в себе макрос Q_OBJECT. Функция ведет себя аналогично стандартному dynamic_cast, но при этом не использует RTTI. Вот как описана данная функция в Qt 4.7.0:
Итак, что тут происходит:
Во-первых если не определены QT_NO_MEMBER_TEMPLATES (определяется только в том случае, если используется версия Microsoft Visual Studio ниже 2002) и QT_NO_QOBJECT_CHECK (определяется в случае использования версии Microsoft Visual Studio ниже 2003), то происходит проверка наличия макроса Q_OBJECT в объявлении класса. И после этого выполняется непосредственно само преобразование — сначала получаем статический объект класса QMetaObject, который называется staticMetaObject, у которого вызывается метод cast, который возвращает const_cast переданного ему объекта, попутно проверяя наследуется ли данный объект от QObject. Далее полученному объекту делается static_cast и возвращается результат.
Приводит объект класса QVariant к нужному классу. Функция аналогична функции qVariantValue.
Рассмотрим, что происходит внутри:
В первой секции кода производится получение идентификатора класса через метасистему Qt. В том случае если класс не зарегистрирован через Q_DECLARE_METATYPE, компиляция кода с приведением к этому типу выдаст ошибку. Далее, если тип объекта, полученный от метасистемы совпадает с типом в значении QVariant, производится reinterpret_cast содержимого объекта, если идентификатор класса не является встроенным типом и его id не совпадает с заложенным в значении QVariant, то возвращается TYPE(). Для случаев, когда мы приводим к встроенному типу, вызывается функция qvariant_cast_helper, которая вызывает в свою очередь функцию convert, адрес которой хранится в структуре Handler. В ней уже осуществляется приведение способом подходящим для типа TYPE. Если конвертация не удалась возвращается объект TYPE()
UPD: Спасибо BaJlepa:
1. const_cast также умеет добавлять cv-квалификаторы
2. для преобразования указателей лучше использовать двойной static_cast через void* вместо reinterpret_cast, потому как такое преобразование позволяет быть уверенным в том, что только pointer-ы участвуют в приведении
Преобразование типов
Операторы позволяют преобразовывать типы данных от одних к другим. Есть пять типов операторов casts:
Рассмотрим каждый из преобразований типов поподробней.
Начнем с явного преобразования типа.
К ним можно отнести такие как:
c-style cast и static_cast
c-style cast
Из названия следует что это пришло из программирования на языке C. Данный метод позволяет осуществить явное преобразование с помощью оператора (). Внутри скобок пишется тип, в который нужно конвертировать.
Данной стиль не проверяется компилятором, поэтому может быть неправильно использован. При преобразование большего типа в меньший случится переполнение.
Данный способ следует использовать с пониманием с осторожностью.
static_cast
Используется для конвертации одного фундаментального типа в другой.
В результате будет выведено число 97 а не символ ‘a’.
Данный тип проверяется компилятором во время компиляции.
При использовании операторов явного преобразования в неявном преобразовании приведет к Warning сообщением при компиляции.
Динамическое приведение типов
dynamic_cast
Данный оператор может быть применен к указателям или ссылкам. При применении полиморфизма можно столкнутся с ситуацией, когда есть указатель на родительский класс, но нужно получить доступ к данным которые есть в дочернем классе. В случае если осуществляется преобразование указателя, который содержит адрес объекта-родителя, к указателю типа объекта-потомка, то в результате преобразования будет получен нулевой указатель. При работе с ссылками при неправильном преобразовании будет сгенерировано исключение std::bad_cast.
Проверка корректности приведения типа производится во время выполнения программы.
Фрагмент кода для наглядного примера:
const_cast
Снятия или установка модификатора const. Применяется что бы обойти неудачную архитектуру или не состыковки си с с++.
Фрагмент кода для демонстрации:
reinterpret_cast
reinterpret_cast — превращает один тип непосредственно в другой — например, приведение значения от одного указателя к другому или сохранение указателя в int. По большому счету, единственная гарантия, которую вы получаете с reinterpret_cast, заключается в том, что обычно, если привести результат обратно к исходному типу, можно получить точно такое же значение (но не в том случае, если промежуточный тип меньше исходного типа). Существует ряд преобразований, которые reinterpret_cast тоже не может выполнить. Он используется главным образом для особенно странных преобразований и битовых манипуляций, таких как превращение потока необработанных данных в реальные данные или хранение данных в младших битах указателя на выровненные данные.
reinterpret_cast в C ++ | Операторы типа Cast
reinterpret_cast — это тип оператора приведения, используемый в C ++.
// Программа CPP для демонстрации работы
// reinterpret_cast
#include
using namespace std;
int * p = new int (65);
char * ch = reinterpret_cast char *>(p);
Цель использования reinterpret_cast
// код CPP для иллюстрации использования структуры
#include
using namespace std;
// создание структуры mystruct
// тип данных должен быть одинаковым во время приведения
// преобразование указателя ‘s’ в,
// указатель типа int в ‘p’.
int * p = reinterpret_cast int *>(&s);
// печать значения, на которое в данный момент указывает * p
// увеличиваем указатель на 1
// печать следующего целочисленного значения
// мы отбрасываем назад символ * указал
// по p, используя char * ch.
char * ch = reinterpret_cast char *>(p);
// печать значения символа
/ * так как, (* ch) теперь указывает на логическое значение,
поэтому требуется доступ к значению с помощью
тот же тип преобразования. поэтому мы использовали
тип данных * n будет bool. * /
bool * n = reinterpret_cast bool *>(ch);
// мы также можем использовать эту строку кода для
// выводим значение, обозначенное (* ch).
cout reinterpret_cast bool *>(ch));
// код CPP для иллюстрации переинтерпретации указателя
#include