const_cast vs reinterpret_cast

Se référant à la C++ FAQ Quand doit-static_cast, dynamic_cast et reinterpret_cast être utilisé?.

const_cast est utilisé pour supprimer ou ajouter des const à une variable et c'est le seul fiable, de définition et de manière légale pour supprimer le constness.
reinterpret_cast est utilisé pour modifier l'interprétation d'un type.

Je comprends, d'une manière raisonnable, pourquoi une variable const doit être commentée à la non-const uniquement à l'aide de const_cast, mais je ne peux pas trouver une justification raisonnable de problèmes à l'aide de reinterpret_cast au lieu de const_cast pour ajouter constness.

Je comprends que l'utilisation de reinterpret_cast de même l'ajout de constness n'est pas sain d'esprit, mais serait-il un UB ou bombe à retardement potentielle pour l'utilisation de reinterpret_cast pour ajouter constness?

La raison qui m'a confondu ici est à cause de la déclaration

En grande partie, la seule garantie que vous obtenez avec reinterpret_cast, c'est que si
vous lancez le résultat en arrière à l'original, vous obtiendrez exactement
même valeur.

Donc si j'ajoute constness à l'aide de reinterpret_cast et si vous reinterpret_cast le résultat en arrière à l'original, il devrait en résulter un retour pour le type d'original et ne doit pas être UB, mais qui ne respecte pas le fait que l'on ne devrait utiliser const_cast pour supprimer le constness

Sur une Note séparée, la norme garantit que Vous pouvez ajouter Constness à l'aide de réinterpréter le cas

5.2.10 Réinterpréter cast (7) ......Lorsqu'un prvalue v de type “pointeur vers T1” est converti dans le type “pointeur vers cv T2”, le résultat est
static_cast(static_cast(v)) si T1 et T2 sont
standard-types de mise en page (3.9) et l'alignement des exigences de T2 sont
pas plus strictes que celles de T1........

  • Pouvez-vous svp me référer à la double question que répond ce?
  • const_cast couvre également l'ajout et de la suppression de volatile.
  • Oui certainement, mais mon objectif actuel est seulement constness
  • Cette déclaration doit se lire "...si vous reinterpret_cast le résultat en arrière à l'original de type..."
InformationsquelleAutor Abhijit | 2013-01-11
  1. 11

    reinterpret_cast change l'interprétation des données à l'intérieur de l'objet. const_cast ajoute ou supprime l' const qualificatif. Représentation des données et constness sont orthogonaux. Il est donc logique d'avoir différents fonte de mots clés.

    Donc si j'ajoute constness à l'aide de reinterpret_cast et si vous reinterpret_cast le résultat en arrière à l'original, il devrait en résulter un retour pour le type d'original et ne doit pas être UB, mais qui ne respecte pas le fait que l'on ne devrait utiliser const_cast pour supprimer le constness

    Qui ne serait même pas compiler:

    int * n = new int;
const * const_added = reinterpret_cast<const int *>(n);
int * original_type = reinterpret_cast<int*>(const_added);
    //error: reinterpret_cast from type ‘const int*’ to type ‘int*’ casts away qualifiers
    • Reportez-vous 5.2.10 Reinterpret cast: When a prvalue v of type “pointer to T1” is converted to the type “pointer to cv T2”, the result is static_cast<cv T2*>(static_cast<cv void*>(v)) if both T1 and T2 are standard-layout types (3.9) and the alignment requirements of T2 are no stricter than those of T1.. Donc, il semble que vous pouvez ajouter constness à l'aide de réinterpréter exprimés.
    • Non-const objets peuvent toujours être implicitement converti à const sans exiger n'importe quelle distribution que ce soit. Je ne vois pas pourquoi reinterpret_cast devrait être une exception à cette règle.
    InformationsquelleAutor StackedCrooked
  2. 4

    Vous ne devriez pas juste ajouter const avec reinterpret_cast. Un reinterpret_cast devrait être principalement que: réinterpréter le pointeur (ou autre).

    En d'autres termes, si vous allez à const char* à char* (je l'espère parce qu'il y a une mauvaise API, vous ne pouvez pas modifier), puis const_cast est votre ami. C'est vraiment tout ce qu'elle est censée être.

    Mais si vous avez besoin d'aller de MyPODType* à const char*, vous avez besoin reinterpret_cast, et c'est juste d'être gentil en ne nécessitant pas un const_cast sur le dessus de cela.

    InformationsquelleAutor Mike DeSimone
  3. 1

    Il y a une chose à garder à l'esprit: Vous ne pouvez pas utiliser const_cast de faire un const variable à l'écriture. Vous ne pouvez l'utiliser pour récupérer un non-const de référence à partir d'une référence const si c'const référence renvoie à un non-const objet. Cela vous semble compliqué? Exemple:

    //valid:
int x;
int const& x1 = x;
const_cast<int&>(x1) = 0;
//invalid:
int const y = 42;
int const& y1 = y;
const_cast<int&>(y1) = 0;

    En réalité, ces deux compiler et parfois même de "travail". Cependant, celle-ci provoque un comportement indéterminé et dans de nombreux cas la fin du programme lorsque le constant objet est placé dans la mémoire en lecture seule.

    Cela dit, un peu plus de choses: reinterpret_cast est le plus puissant de fonte, mais aussi la plus dangereuse, afin de ne pas les utiliser à moins que vous ne devez. Lorsque vous avez besoin pour aller de void* à sometype*, utilisez static_cast. Lorsque vous allez à l'opposé de la direction, appel à la conversion implicite ou l'utilisation explicite static_cast, trop. De même avec l'ajout ou la suppression const, qui est également ajouté implicitement. Concernant reinterpret_cast, voir aussi la discussion au C++ Quand doit-on préférer l'utilisation d'un deux enchaînés static_cast sur reinterpret_cast où une alternative qui est moins hackish est discutée.

    Uli

    InformationsquelleAutor Ulrich Eckhardt
  4. 0

    Le seul endroit où je peux penser pour ce qui concerne la reinterpret_cast avec const-ness est lors du passage d'un const objet d'une API qui accepte un pointeur void -

    UINT ThreadFunction(void* param)
{
    const MyClass* ptr = reinterpret_cast<const MyClass*>(param);
}
    InformationsquelleAutor Superman
  5. 0

    oui, comme vous le savez, const_cast signifie qu'il supprime constness à partir d'un type spécifique.

    Mais, lorsque nous avons besoin d'ajouter constness à un type. Est-il une raison pour laquelle nous avons à faire?

    par exemple, 

    void PrintAnything(void* pData)
{
    const CObject* pObject = reinterpret_cast<CObject*>(pData);
    //below is bla-bla-bla.
}

    reinterpret_cast n'a rien à voir avec la 'const'.

    const_cast signifie deux choses.
    la première consiste à supprimer constness à partir d'un type, et l'autre est de donner son code explicite. Parce que vous pouvez utiliser les lancer à l'aide de C-style coulé, mais ce n'est pas explicite, ce n'est donc pas recommandé.

    Ils ne fonctionnent pas de même. c'est vraiment différent.

    InformationsquelleAutor VariOov