Вставить int в unsigned int c ++ [duplicate]

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

Ниже приведены некоторые практические примеры, когда я использовал 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);
}

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

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

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

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

В дополнение к остальным ответам до сих пор здесь неочевидный пример, где 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 (at цена дополнительной переменной) следующим образом:

#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 to int. Используйте static_cast для них.
• Как правило, при преобразовании типа A в B static_cast будет вызывать конструктор B, передающий его A. Если B не имеет такого конструктора, тогда вы получаете ошибку времени компиляции.
• Отправлено от A* до B* всегда, если A и B находятся в иерархии наследования (или void), в противном случае вы получите ошибку компиляции.
• Gotcha: Если вы указали базовый указатель к производному указателю, но если фактический объект есть, если не производный тип, то вы не получите ошибку. Вы получаете плохой указатель, и как только вы пытаетесь получить доступ к элементам производного указателя, вы получаете segfault во время выполнения.
• То же самое для A& - B&.
• Gotcha: Бросьте из Derived в Base или наоборот, создайте новую копию!

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

reinterpret_cast

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

Ответил ли этот на ваш вопрос?

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

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

Для начинающих C ++ C -style casts выглядит как операция надмножества над листами C ++ (static_cast & lt;> (), dynamic_cast & lt;> (), const_cast & lt;> (), reinterpret_cast & lt;> ()), и кто-то может предпочесть их по сравнению с C ++-переходами. Фактически, C-стиль является надмножеством и короче для записи.

Основная проблема приведения в стиле C заключается в том, что они скрывают замыслы разработчика в отношении создания. Стили C-стиля могут выполнять практически все типы отливок из обычно безопасных отбрасываний, выполняемых static_cast & lt;> () и dynamic_cast & lt;> (), в потенциально опасные роли, такие как const_cast & lt;> (), где модификатор const может быть удален, поэтому константные переменные могут быть изменены и reinterpret_cast & lt;> (), которые могут даже переинтерпретировать целочисленные значения указателям.

Вот пример.

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-style.

Вот короткая цитата из книги Bjarne Stroustrup (автора C ++). Язык программирования C ++ 4th edition - стр. 302.

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