Когда следует использовать static_cast, dynamic_cast, const_cast и reinterpret_cast?

это отвечает на ваш вопрос?

Я никогда не использовал reinterpret_cast и задаюсь вопросом, не пахнет ли чехол, который в нем нуждается, плохим дизайном. В кодовой базе, которую я работаю, много используется dynamic_cast. Разница с static_cast заключается в том, что dynamic_cast выполняет проверку во время выполнения, которая может (безопаснее) или не может (больше накладных расходов) быть тем, что вы хотите (см. msdn).

Используйте dynamic_cast для преобразования указателей / ссылок в иерархии наследования.

Используйте static_cast для преобразования обычных типов.

Используйте reinterpret_cast для низкоуровневой переинтерпретации битовых шаблонов. Используйте с особой осторожностью.

Используйте const_cast для отбрасывания const/volatile. Избегайте этого, если вы не застряли в использовании API, неверного по константе.

static_cast - это первое приведение, которое вы должны попытаться использовать. Он выполняет такие вещи, как неявные преобразования между типами (например, int в float или указатель на void*), а также может вызывать функции явного преобразования (или неявные). Во многих случаях явно указывать static_cast не обязательно, но важно отметить, что синтаксис T(something) эквивалентен (T)something, и его следует избегать (подробнее об этом позже). Однако T(something, something_else) безопасен и гарантированно вызывает конструктор.

static_cast также может проходить через иерархии наследования. В этом нет необходимости при приведении вверх (к базовому классу), но при приведении вниз его можно использовать, если оно не выполняется через наследование virtual. Однако он не выполняет проверку, и это неопределенное поведение для static_cast вниз по иерархии до типа, который на самом деле не является типом объекта.

const_cast может использоваться для удаления или добавления const к переменной; никакое другое приведение C++ не способно удалить его (даже reinterpret_cast). Важно отметить, что изменение ранее существовавшего значения const не определено только в том случае, если исходной переменной является const; если вы используете его, чтобы убрать ссылку на const на то, что не было объявлено с const, это безопасно. Это может быть полезно, например, при перегрузке функций-членов на основе const. Его также можно использовать для добавления const к объекту, например для вызова перегрузки функции-члена.

const_cast также работает аналогично с volatile, хотя это встречается реже.

dynamic_cast используется исключительно для обработки полиморфизма. Вы можете привести указатель или ссылку на любой полиморфный тип к любому другому типу класса (полиморфный тип имеет по крайней мере одну виртуальную функцию, объявленную или унаследованную). Вы можете использовать его не только для заброса вниз - вы можете забрасывать его боком или даже вверх по другой цепи. dynamic_cast найдет желаемый объект и, если возможно, вернет его. Если не может, он вернет nullptr в случае указателя или выбросит std::bad_cast в случае ссылки.

Однако dynamic_cast имеет некоторые ограничения. Это не работает, если в иерархии наследования есть несколько объектов одного типа (так называемый «ужасный ромб») и вы не используете наследование virtual. Он также может пройти только через публичное наследование - он всегда не сможет пройти через наследование protected или private. Однако это редко является проблемой, поскольку такие формы наследования редки.

reinterpret_cast - наиболее опасное приведение, и его следует использовать очень экономно. Он превращает один тип напрямую в другой - например, преобразование значения из одного указателя в другой, или сохранение указателя в int, или множество других неприятных вещей. По большому счету, единственная гарантия, которую вы получаете с reinterpret_cast, заключается в том, что обычно, если вы возвращаете результат обратно к исходному типу, вы получите точно такое же значение (но нет, если промежуточный тип меньше исходного типа). reinterpret_cast также не может выполнять ряд преобразований. Он используется в основном для особенно странных преобразований и битовых манипуляций, таких как преобразование потока необработанных данных в фактические данные или хранение данных в младших битах указателя на выровненные данные.

C-стиль гипс и приведение в функциональном стиле представляют собой приведения с использованием (type)object или type(object), соответственно, и функционально эквивалентны. Они определяются как первые из следующих успешных:

• const_cast
• static_cast (правда, игнорируя ограничения доступа)
• static_cast (см. Выше), затем const_cast
• reinterpret_cast
• reinterpret_cast, затем const_cast

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

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

(Выше было дано много теоретических и концептуальных объяснений)

Ниже приведены некоторые из практические примеры, когда я использовал static_cast, dynamic_cast, const_cast, reinterpret_cast.

(Также ссылается на это, чтобы понять объяснение: http://www.cplusplus.com/doc/tutorial/typecasting/)

static_cast:

OnEventData(void* pData)

{
  ......

  //  pData is a void* pData, 

  //  EventData is a structure e.g. 
  //  typedef struct _EventData {
  //  std::string id;
  //  std:: string remote_id;
  //  } EventData;

  // On Some Situation a void pointer *pData
  // has been static_casted as 
  // EventData* pointer 

  EventData *evtdata = static_cast<EventData*>(pData);
  .....
}

dynamic_cast:

void DebugLog::OnMessage(Message *msg)
{
    static DebugMsgData *debug;
    static XYZMsgData *xyz;

    if (debug = dynamic_cast<DebugMsgData*>(msg->pdata)){
        // debug message
    }
    else if (xyz = dynamic_cast<XYZMsgData*>(msg->pdata)){
        // xyz message
    }
    else/* if ( ... )*/{
        // ...
    }
}

const_cast:

// *Passwd declared as a const

const unsigned char *Passwd


// on some situation it require to remove its constness

const_cast<unsigned char*>(Passwd)

reinterpret_cast:

typedef unsigned short uint16;

// Read Bytes returns that 2 bytes got read. 

bool ByteBuffer::ReadUInt16(uint16& val) {
  return ReadBytes(reinterpret_cast<char*>(&val), 2);
}

В дополнение к другим ответам, приведенным на данный момент, вот неочевидный пример, когда static_cast недостаточно, поэтому необходим reinterpret_cast. Предположим, есть функция, которая в выходном параметре возвращает указатели на объекты разных классов (которые не имеют общего базового класса). Реальный пример такой функции - CoCreateInstance() (см. Последний параметр, которым на самом деле является void**). Предположим, вы запрашиваете у этой функции конкретный класс объекта, поэтому вы заранее знаете тип указателя (что вы часто делаете для COM-объектов). В этом случае вы не можете преобразовать указатель на ваш указатель в void** с помощью static_cast: вам нужен reinterpret_cast<void**>(&yourPointer).

В коде:

#include <windows.h>
#include <netfw.h>
.....
INetFwPolicy2* pNetFwPolicy2 = nullptr;
HRESULT hr = CoCreateInstance(__uuidof(NetFwPolicy2), nullptr,
    CLSCTX_INPROC_SERVER, __uuidof(INetFwPolicy2),
    //static_cast<void**>(&pNetFwPolicy2) would give a compile error
    reinterpret_cast<void**>(&pNetFwPolicy2) );

Однако static_cast работает с простыми указателями (а не с указателями на указатели), поэтому приведенный выше код можно переписать, чтобы избежать использования reinterpret_cast (за счет дополнительной переменной), следующим образом:

#include <windows.h>
#include <netfw.h>
.....
INetFwPolicy2* pNetFwPolicy2 = nullptr;
void* tmp = nullptr;
HRESULT hr = CoCreateInstance(__uuidof(NetFwPolicy2), nullptr,
    CLSCTX_INPROC_SERVER, __uuidof(INetFwPolicy2),
    &tmp );
pNetFwPolicy2 = static_cast<INetFwPolicy2*>(tmp);

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

static_cast

• Компилятор C++ уже знает, как преобразовывать между типами масштабирования, такими как float, в int. Используйте для них static_cast.
• Когда вы просите компилятор преобразовать тип A в B, static_cast вызывает конструктор B, передавая A в качестве параметра. В качестве альтернативы, A может иметь оператор преобразования (например, A::operator B()). Если B не имеет такого конструктора или A не имеет оператора преобразования, вы получите ошибку времени компиляции.
• Приведение из A* в B* всегда успешно, если A и B находятся в иерархии наследования (или недействительны), в противном случае вы получите ошибку компиляции.
• Попался: если вы приведете базовый указатель к производному указателю, но если фактический объект действительно не является производным типом, вы получите ошибку не. Вы получаете плохой указатель и, скорее всего, ошибку сегментации во время выполнения. То же самое касается A& - B&.
• Попался: преобразование из производного в базовое или наоборот создает копию новый! Для людей, пришедших с C# / Java, это может быть огромным сюрпризом, потому что в результате получается обрезанный объект, созданный из Derived.

dynamic_cast

• dynamic_cast использует информацию о типе времени выполнения, чтобы выяснить, допустимо ли приведение. Например, переход от (Base*) к (Derived*) может завершиться ошибкой, если указатель на самом деле не является производным типом.
• Это означает, что dynamic_cast очень дорого по сравнению со static_cast!
• Для A* в B*, если приведение недопустимо, то dynamic_cast вернет nullptr.
• Для A& в B&, если приведение недопустимо, то dynamic_cast вызовет исключение bad_cast.
• В отличие от других приведений, это накладные расходы времени выполнения.

const_cast

• Хотя static_cast может преобразовывать неконстантные значения в константу, иначе не может быть. Const_cast может работать обоими способами.
• Один из примеров, когда это удобно, - это итерация через некоторый контейнер, такой как set<T>, который возвращает только свои элементы как const, чтобы убедиться, что вы не изменили его ключ. Однако, если вы намереваетесь изменить неключевые элементы объекта, все должно быть в порядке. Вы можете использовать const_cast для удаления константности.
• Другой пример - когда вы хотите реализовать T& SomeClass::foo(), а также const T& SomeClass::foo() const. Чтобы избежать дублирования кода, вы можете применить const_cast для возврата значения одной функции из другой.

reinterpret_cast

• Это в основном говорит о том, что берите эти байты в этой ячейке памяти и воспринимайте их как заданный объект.
• Например, вы можете загрузить 4 байта float в 4 байта int, чтобы увидеть, как выглядят биты в float.
• Очевидно, что если данные не соответствуют типу, вы можете получить segfault.
• Это приведение не требует дополнительных затрат времени выполнения.

Хотя в других ответах хорошо описаны все различия между приведениями C++, я хотел бы добавить короткое замечание, почему вы не должны использовать приведения в стиле C (Type) var и Type(var).

Для новичков в C++ приведение типов в стиле C выглядит как надстройка над приведением типов в C++ (static_cast <> (), dynamic_cast <> (), const_cast <> (), reinterpret_cast <> ()), и кто-то может предпочесть их приведению C++. . Фактически, приведение в стиле C - это надмножество, и писать его короче.

Основная проблема приведений в стиле C заключается в том, что они скрывают истинное намерение разработчика приведения типов. Приведения в стиле C могут выполнять практически все типы приведения, от обычно безопасных приведения, выполняемых static_cast <> () и dynamic_cast <> (), до потенциально опасных типов, таких как const_cast <> (), где модификатор const может быть удален, чтобы переменные const можно изменить и переинтерпретировать_каст <> (), который даже может переинтерпретировать целочисленные значения в указатели.

Вот образец.

int a=rand(); // Random number.

int* pa1=reinterpret_cast<int*>(a); // OK. Here developer clearly expressed he wanted to do this potentially dangerous operation.

int* pa2=static_cast<int*>(a); // Compiler error.
int* pa3=dynamic_cast<int*>(a); // Compiler error.

int* pa4=(int*) a; // OK. C-style cast can do such cast. The question is if it was intentional or developer just did some typo.

*pa4=5; // Program crashes.

Основная причина, по которой в язык были добавлены преобразования C++, заключалась в том, чтобы позволить разработчику прояснить свои намерения - почему он собирается выполнять это преобразование. Используя приведение типов в стиле C, которые вполне допустимы в C++, вы делаете свой код менее читаемым и более подверженным ошибкам, особенно для других разработчиков, которые не создавали ваш код. Таким образом, чтобы сделать ваш код более читаемым и явным, вы всегда должны предпочесть приведение типов C++, а не приведение типов C.

Вот короткая цитата из книги Бьярна Страуструпа (автора C++) The C++ Programming Language 4th edition - page 302.

This C-style cast is far more dangerous than the named conversion operators because the notation is harder to spot in a large program and the kind of conversion intended by the programmer is not explicit.

Чтобы понять это, давайте рассмотрим нижеприведенный фрагмент кода:

struct Foo{};
struct Bar{};

int main(int argc, char** argv)
{
    Foo* f = new Foo;

    Bar* b1 = f;                              // (1)
    Bar* b2 = static_cast<Bar*>(f);           // (2)
    Bar* b3 = dynamic_cast<Bar*>(f);          // (3)
    Bar* b4 = reinterpret_cast<Bar*>(f);      // (4)
    Bar* b5 = const_cast<Bar*>(f);            // (5)

    return 0;
}

Только строка (4) компилируется без ошибок. Только reinterpret_cast можно использовать для преобразования указателя на объект в указатель на любой несвязанный тип объекта.

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

Когда использовать приведение C++:

• Используйте static_cast как эквивалент приведения в стиле C, который выполняет преобразование значений, или когда нам нужно явно преобразовать указатель от класса к его суперклассу.
• Используйте const_cast, чтобы удалить квалификатор const.
• Используйте reinterpret_cast для небезопасного преобразования типов указателей в целочисленные и другие типы указателей и обратно. Используйте это, только если мы знаем, что делаем, и понимаем проблемы сглаживания.