Quand doit-static_cast, dynamic_cast, const_cast et reinterpret_cast être utilisé?

static_cast est le casting d'abord, vous devriez essayer d'utiliser. Il fait des choses comme les conversions implicites entre les types (tels que int à float, ou un pointeur vers void*), et il peut également appeler les fonctions de conversion explicite (ou implicitement). Dans de nombreux cas, en indiquant expressément static_cast n'est pas nécessaire, mais il est important de noter que la T(something) syntaxe est équivalente à (T)something et doit être évitée (plus sur cela plus tard). Un T(something, something_else) est sûr, cependant, et de la garantie d'appeler le constructeur.

static_cast pouvez également exprimés à travers des hiérarchies d'héritage. Il est inutile lors de la coulée vers le haut (une classe de base), mais lors de la coulée vers le bas, il peut être utilisé tant qu'il n'a pas coulé à travers virtual héritage. Il ne fait pas de vérification, cependant, et c'est un comportement indéfini à static_cast en bas de la hiérarchie à un type qui n'est en fait pas le type de l'objet.

---

const_cast peut être utilisé pour supprimer ou ajouter des const à une variable; aucune autre C++ cast est capable de le retirer (même pas reinterpret_cast). Il est important de noter que la modification d'un anciennement const valeur n'est pas définie si la variable d'origine, est const; si vous l'utilisez pour prendre la const off une référence à quelque chose qui n'était pas déclarée avec const, c'est sûr. Cela peut être utile en cas de surcharge des fonctions de membre basée sur const, par exemple. Il peut également être utilisé pour ajouter const à un objet, comme pour appeler une fonction membre de surcharge.

const_cast fonctionne aussi de la même façon sur volatile, même si c'est moins fréquent.

---

dynamic_cast est exclusivement utilisé pour la manipulation de polymorphisme. Vous pouvez jeter un pointeur ou une référence à tout type polymorphe à tout autre type de classe (un type polymorphe a au moins une fonction virtuelle, déclaré ou hérité). Vous pouvez l'utiliser pour plus que juste de coulée vers le bas, vous pouvez lancer sur le côté ou même d'une autre chaîne. Le dynamic_cast en quête de l'objet désiré et de le retourner si possible. Si il ne peut pas, il sera de retour nullptr dans le cas d'un pointeur, ou de jeter std::bad_cast dans le cas d'une référence.

dynamic_cast a certaines limites, cependant. Il ne fonctionne pas si il y a plusieurs objets de même type dans la hiérarchie d'héritage (la soi-disant "tant redoutée de diamant") et que vous n'utilisez pas virtual héritage. Il a également ne peut que passer par le public de l'héritage - il échouera toujours à voyager à travers protected ou private héritage. C'est rarement un problème, cependant, que de telles formes d'héritage sont rares.

---

reinterpret_cast est le plus dangereux de fonte, et doit être utilisé avec beaucoup de parcimonie. Il tourne un type vers un autre — comme la coulée de la valeur d'un pointeur à un autre, ou le stockage d'un pointeur dans un int, ou toutes autres sortes de choses désagréables. En grande partie, la seule garantie que vous obtenez avec reinterpret_cast est que, normalement, si vous lancez le résultat en arrière à l'original, vous obtiendrez exactement la même valeur (mais pas si le type intermédiaire est plus petit que le type d'origine). Il y a un certain nombre de conversions reinterpret_cast ne peut pas le faire, trop. Il est utilisé principalement pour la particulièrement bizarre conversions et peu de manipulations, comme transformer un flux de données brutes en données réelles, ou le stockage des données dans les bits de poids faible de l'alignement de pointeur.

---

De style C cast et fonction de style de fonte sont des distributions à l'aide (type)object ou type(object), respectivement, et sont fonctionnellement équivalents. Ils sont définis comme le premier de la suivante qui réussit:

• const_cast
• static_cast (mais en ignorant les restrictions d'accès)
• static_cast (voir ci-dessus), puis const_cast
• reinterpret_cast
• reinterpret_cast, puis const_cast

Il peut donc être utilisé comme un remplacement pour les autres distributions, dans certains cas, mais qui peut être extrêmement dangereux en raison de la capacité de se résumer à une reinterpret_cast, et celle-ci devrait être préféré quand une conversion explicite est nécessaire, sauf si vous êtes sûr static_cast va réussir ou reinterpret_cast échouera. Même alors, envisager de le plus, plus explicite option.

C-style jette également ignorer de contrôle d'accès lors de l'exécution d'un static_cast, ce qui signifie qu'ils ont la capacité d'effectuer une opération qu'aucune autre conversion peut. C'est surtout une bidouille, même si, et dans mon esprit, c'est juste une autre raison pour éviter de style C jette.

(Beaucoup de théorique et conceptuel de l'explication qui a été donnée ci-dessus)

Ci-dessous sont quelques-uns des exemples pratiques lorsque j'ai utilisé static_cast, dynamic_cast, const_cast, reinterpret_cast.

(Aussi renvoie 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);
}

Ne cette répondre à votre question?

Je n'ai jamais utilisé reinterpret_cast, et me demande si en cours d'exécution dans un cas, il n'est pas une odeur de mauvaise conception. Dans la base de code, je travaille sur dynamic_cast est beaucoup utilisé. La différence avec static_cast est qu'un dynamic_cast ne contrôle d'exécution qui peut (safer) ou ne peuvent pas (plus les frais généraux) être ce que vous voulez (voir msdn).

Tandis que d'autres réponses joliment décrit toutes les différences entre le C++ jette, je voudrais ajouter une courte note pourquoi vous ne devriez pas utiliser le C-style jette (Type) var et Type(var).

Pour 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 de style C cast est le sur-ensemble et de la plus courte à écrire.

Le principal problème de C-style jette, c'est qu'ils cachent développeur intention réelle de la fonte. Le style C moulages peuvent faire pratiquement tous les types de moulage de normalement sans danger jette fait par static_cast<>() et dynamic_cast<>() pour potentiellement dangereux jette comme const_cast<>(), où const modificateur peut être retiré afin const variables peuvent être modifiées et reinterpret_cast<>() qui permet même de réinterpréter les valeurs entières de 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 raison principale pourquoi C++ fontes ont été ajoutés à la langue était de permettre à un développeur de clarifier ses intentions, pourquoi il va le faire en fonte. À l'aide de C-style de moulages qui sont parfaitement valide en C++, vous faites de votre code moins lisible et plus enclins à faire des erreurs, surtout pour les autres développeurs qui n'ont pas de créer votre code. Afin de rendre votre code plus lisible et explicite, vous devez toujours préférer C++ jette sur C-style jette.

Ici est une courte citation de Bjarne Stroustrup (l'auteur de C++) du livre Le Langage de Programmation C++ 4e édition - page 302.

Ce style C cast est bien plus dangereux que le nommé opérateurs de conversion
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.