Quand doit-on utiliser la fonte statique, la fonte dynamique, la fonte en const et la fonte réinterprétée?

Utiliser dynamic_cast pour la conversion des pointeurs/références au sein d'une hiérarchie d'héritage.

utiliser static_cast pour les conversions de type ordinaire.

utiliser reinterpret_cast pour réinterpréter de bas niveau des modèles de bits. Utiliser avec une extrême prudence.

utiliser const_cast pour rejeter const/volatile . Évitez cela à moins que vous ne soyez bloqué en utilisant une API const-incorrect.

(beaucoup d'explications théoriques et conceptuelles ont été données ci-dessus)

ci-Dessous sont quelques-uns des exemples concrets lorsque j'ai utilisé static_cast , dynamic_cast , const_cast , reinterpret_cast .

(renvoie aussi à cela pour comprendre l'explication: 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);
}

cela pourrait aider si vous connaissez un peu des internes...

static_cast

• le compilateur C++ sait déjà convertir des types de scalers tels que float en int. Utilisez static_cast pour eux.
• en cas général de conversion de type A en B , static_cast appelle B 's constructeur passant A comme param. Si B n'a pas un tel constructeur génère alors une erreur de compilation.
• Cast de A* à B* réussit toujours si A et B sont dans la hiérarchie d'héritage (ou nulle), sinon vous obtenez des erreurs lors de la compilation.
• Gotcha : si vous lancez pointeur de base vers pointeur dérivé, mais si l'objet réel n'est pas vraiment type dérivé, alors vous don't get error. Vous obtenez mauvais pointeur et segfault à l'exécution. En va de même pour A& à B& .
• Gotcha : moulé à partir de dérivé à la Base ou viceversa crée nouveau copie! Pour les personnes venant de C#/Java, cela peut être une énorme surprise.

dynamic_cast

• dynamic_cast utilise des informations de type runtime pour déterminer si cast est valide. Par exemple, (Base*) à (Derived*) peut échouer si le pointeur n'est pas réellement de type dérivé.
• cela signifie que dynamic_cast est très cher comparé à static_cast!
• Pour A* à B* , si la fonte n'est pas valide alors dynamic_cast sera de retour nullptr.
• pour A& à B& si cast est invalide, dynamic_cast lancera l'exception bad_cast.
• Contrairement aux autres moulages, il y a des temps d'exécution au-dessus.

const_cast

• alors que static_cast peut faire non-const pour const, il ne peut pas aller dans un autre sens. Le const_cast peut faire les deux.
• un exemple où cela s'avère pratique est l'itération dans un conteneur comme set<T> qui ne renvoie ses éléments que comme const pour s'assurer que vous ne changez pas sa clé. Cependant si votre intention est de modifier l'objet du non-membres clés alors qu'il devrait être ok. Vous pouvez utiliser const_cast pour supprimer Constance.
• un autre exemple est quand vous voulez implémenter T& foo() ainsi que const T& foo() . Pour éviter la duplication de code, vous pouvez appliquer const_cast pour retourner la valeur d'une fonction à une autre.

reinterpret_cast

• cela dit fondamentalement que prendre ces octets à cet endroit de la mémoire et penser à lui comme objet donné.
• par exemple, vous pouvez charger 4 octets de float à 4 octets d'int pour voir comment les bits dans float ressemble.
• évidemment, si les données ne sont pas correctes pour le type, vous pouvez obtenir segfault.
• il n'y a pas de runtime overhead pour cette distribution.

est-ce que ce répond à votre question?

Je n'ai jamais utilisé reinterpret_cast , et je me demande si le fait de tomber sur une affaire qui en a besoin n'est pas une odeur de mauvais design. Dans la base de code, je travaille sur dynamic_cast est beaucoup utilisé. La différence avec static_cast est qu'un dynamic_cast fait le contrôle d'exécution qui peut être (plus sûr) ou peut ne pas être (plus au-dessus) ce que vous voulez (voir msdn ).

en plus des autres réponses jusqu'à présent, voici un exemple peu évident où static_cast n'est pas suffisant pour que reinterpret_cast soit nécessaire. Supposons qu'il y ait une fonction qui, dans un paramètre de sortie, renvoie des pointeurs vers des objets de différentes classes (qui ne partagent pas de classe de base commune). Un exemple réel d'une telle fonction est CoCreateInstance() (voir le dernier paramètre, qui est en fait void** ). Supposons que vous demandiez à cette classe particulière d'objet fonction, de sorte que vous connaissez à l'avance le type pour le pointeur (ce que vous faites souvent pour les objets COM). Dans ce cas, vous ne pouvez pas lancer pointeur sur votre pointeur dans void** avec static_cast : vous avez besoin de reinterpret_cast<void**>(&yourPointer) .

dans le code:

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

cependant, static_cast fonctionne pour les pointeurs simples (pas de pointeurs vers les pointeurs), de sorte que le code ci-dessus peut être réécrit pour éviter reinterpret_cast (à un prix d'une variable supplémentaire) de la manière suivante:

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

alors que d'autres réponses décrivaient bien toutes les différences entre les casts C++, j'aimerais ajouter une petite note expliquant pourquoi vous ne devriez pas utiliser les casts C-style (Type) var et Type(var) .

Pour le C++ débutants C-style jette ressemble en apparence le sur-ensemble de l'opération sur C++ jette (static_cast<>(), dynamic_cast<>(), const_cast<>(), reinterpret_cast<>()) et si quelqu'un pourrait préférez sur le C++ jette. En fait, c-style cast est le superset et plus court à écrire.

le problème principal des plâtres de style C est qu'ils cachent l'intention réelle du développeur de la distribution. Les coulées de style C peuvent faire pratiquement tous les types de coulées à partir de coulées normalement sûres faites par static_cast<>() et dynamic_cast<>() à des coulées potentiellement dangereuses comme const_cast<>(), où le modificateur de const peut être enlevé de sorte que les variables de const peuvent être modifiées et réinterpret_cast<>() qui peut même réinterpréter des valeurs entières à des pointeurs.

Voici l'échantillon.

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.

la principale raison pour laquelle les casts C++ ont été ajoutés au langage était de permettre à un développeur de clarifier ses intentions - pourquoi il va faire ce cast. En utilisant C-style casts qui sont parfaitement valides en C++ vous rendez votre code moins lisible et plus sujet aux erreurs surtout pour les autres développeurs qui n'ont pas créé votre code. Ainsi, pour rendre votre code plus lisible et explicite, vous devriez toujours préférer les casts C++ aux casts C-style.

voici une courte citation de Bjarne Stroustrup (l'auteur de C++) livre le langage de programmation C++ 4ème édition-page 302.

ce moulage de style C est beaucoup plus dangereux que les opérateurs de conversion nommés parce que la notation est plus difficile à repérer, dans un large programme et le type de conversion prévu par le programmeur n'est pas explicite.