Kiedy należy stosować odlew statyczny, odlew dynamiczny,odlew const i reinterpret?

Użyj dynamic_cast do konwersji wskaźników / odniesień w hierarchii dziedziczenia.

Użyj static_cast do konwersji zwykłych typów.

Użyj reinterpret_cast do niskopoziomowej reinterpretacji wzorców bitowych. Stosować ze szczególną ostrożnością.

Użyj const_cast do odrzucenia const/volatile. Unikaj tego, chyba że utkniesz przy użyciu niepoprawnego API.

(Wiele teoretycznych i pojęciowych wyjaśnień zostało podanych powyżej)

Poniżej kilka z praktycznych przykładów kiedy użyłem static_cast, dynamic_cast, const_cast, reinterpret_cast .

(odnosi się również do tego, aby zrozumieć Wyjaśnienie: 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);
}

To może pomóc, jeśli znasz trochę wewnętrznych...

Static_cast

• kompilator C++ wie już, jak przekonwertować typy skalerów, takie jak float do int. Użyj static_cast dla nich.
• w ogólnym przypadku konwersji z typu A na B, static_cast wywołanie konstruktora B przekazującego A jako param. Jeśli B nie ma takiego konstruktora, to pojawia się błąd czasu kompilacji.
• rzut od A* do B* zawsze się powiedzie, jeśli a i B są w dziedziczeniu hierarchia (lub void) w przeciwnym razie dostajesz błąd kompilacji.
• Gotcha : jeśli rzucisz wskaźnik bazowy na wskaźnik Pochodny, ale jeśli rzeczywisty obiekt nie jest tak naprawdę typem pochodnym, to nie otrzymasz błędu. Masz zły wskaźnik i segfault w czasie wykonywania. To samo dotyczy A& do B&.
• Gotcha : Cast from Derived to Base or viceversa creates new copy! Dla ludzi wywodzących się z C# / Javy może to być ogromny niespodzianka.

Dynamic_cast

• dynamic_cast używa informacji typu runtime, aby dowiedzieć się, czy cast jest poprawny. Na przykład, (Base*) do (Derived*) może się nie udać, jeśli wskaźnik nie jest typem pochodnym.
• oznacza to, że dynamic_cast jest bardzo drogi w porównaniu do static_cast!
• dla A* do B*, jeśli Cast jest nieprawidłowy, to dynamic_cast zwróci nullptr.
• For A& to B& if cast is invalid then dynamic_cast will throw bad_cast wyjątek.
• W przeciwieństwie do innych odlewów, istnieje nadmiarowość runtime.

Const_cast

• podczas gdy static_cast może wykonywać non-const do const, nie może iść w drugą stronę. Const_cast może działać w obie strony.
• jednym z przykładów, gdzie jest to przydatne, jest iteracja przez jakiś kontener podobny do set<T>, który zwraca tylko swoje elementy jako const, aby upewnić się, że nie zmienisz jego klucza. Jeśli jednak chcesz zmodyfikować inne elementy obiektu, to powinno być ok. Możesz użyć const_cast, aby usunąć constness.
• Innym przykładem jest, gdy chcesz zaimplementować T& foo(), a także const T& foo(). Aby uniknąć powielania kodu, możesz zastosować const_cast do zwracania wartości jednej funkcji z drugiej.

Reinterpret_cast

• to w zasadzie mówi, że pobieramy te bajty w tym miejscu pamięci i traktujemy je jako dany obiekt.
• na przykład, można załadować 4 bajty float do 4 bajtów int, aby zobaczyć jak bity w float wyglądają na przykład.
• oczywiście, jeśli dane nie są poprawne dla typu, możesz uzyskać segfault.
• nie ma nadmiarowego czasu wykonania dla tej obsady.

Czyto odpowiada na twoje pytanie?

Nigdy nie używałem reinterpret_cast i zastanawiam się, czy wpadanie w sprawę, która tego potrzebuje, nie jest zapachem złego designu. W kodzie bazowym, na którym pracuję dynamic_cast jest często używany. Różnica w stosunku do static_cast polega na tym, że dynamic_cast wykonuje sprawdzanie, które może (bezpieczniejsze) lub nie (więcej kosztów) być tym, czego chcesz (zobacz msdn).

Oprócz innych odpowiedzi do tej pory, tutaj jest nieoczywisty przykład, gdzie {[2] } nie wystarcza, aby reinterpret_cast było potrzebne. Załóżmy, że istnieje funkcja, która w parametrze wyjściowym zwraca wskaźniki do obiektów różnych klas (które nie mają wspólnej klasy bazowej). Prawdziwym przykładem takiej funkcji jest CoCreateInstance() (Zobacz ostatni parametr, który w rzeczywistości jest void**). Załóżmy, że żądasz określonej klasy obiektu z tej funkcji, więc znasz z góry typ wskaźnika (co często robisz dla obiektów COM). W tym przypadku nie możesz dodać wskaźnika do wskaźnika do void** z static_cast: potrzebujesz reinterpret_cast<void**>(&yourPointer).

W kodzie:

#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) );

Jednak static_cast działa dla prostych wskaźników (nie dla wskaźników do wskaźników), więc powyższy kod można przepisać, aby uniknąć reinterpret_cast (za cenę dodatkowej zmiennej) w następujący sposób:

#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);

Podczas gdy inne odpowiedzi ładnie opisywały wszystkie różnice między odlewami C++, chciałbym dodać krótką notatkę, dlaczego nie powinieneś używać odlewów w stylu C (Type) var i Type(var).

Dla początkujących C++ odlewy w stylu C wyglądają jak operacja superset nad odlewami w C++ (static_cast (), dynamic_cast (), const_cast (), reinterpret_cast ()) i ktoś mógłby preferować je nad odlewami w C++. W rzeczywistości Obsada w stylu C jest superset i krótsza do napisania.

Głównym problemem odlewów w stylu C jest to, że ukrywają prawdziwe intencje obsady. Odlewy w stylu C mogą wykonywać praktycznie wszystkie typy odlewów z normalnie bezpiecznych odlewów wykonanych przez static_cast () i dynamic_cast () do potencjalnie niebezpiecznych odlewów, takich jak const (), gdzie modyfikator const może być usunięty, więc zmienne const mogą być modyfikowane i reinterpret_cast (), które mogą nawet reinterpretować wartości całkowite do wskaźników.

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.

Głównym powodem dodania C++ do języka było umożliwienie programista, aby wyjaśnić swoje intencje-dlaczego zamierza to zrobić. Używając odlewów w stylu C, które są doskonale poprawne w C++, sprawiasz, że Twój kod jest mniej czytelny i bardziej podatny na błędy, szczególnie dla innych programistów, którzy nie stworzyli Twojego kodu. Tak więc, aby Twój kod był bardziej czytelny i wyraźny, zawsze powinieneś preferować odlewy w C++ niż odlewy w stylu C.

Oto krótki cytat z książki Bjarne Stroustrupa (autora C++) The C++ Programming Language 4th edition-strona 302.

Ta Obsada w stylu C jest znacznie bardziej niebezpieczna niż nazwane operatory konwersji ponieważ zapis jest trudniejszy do zauważenia w dużym programie, a rodzaj konwersji zamierzony przez programistę nie jest jednoznaczny.