Espaces de noms
Variantes
Affichages
Actions

dynamic_cast conversion

De cppreference.com
< cpp‎ | language

 
 
Langage C++
Sujets généraux
Contrôle de flux
Instructions conditionnelles
Instructions d'itération
Instructions de saut
Fonctions
déclaration de fonction
expression lambda
fonction générique
spécificateur inline
spécification d'exception (obsolète)
spécificateur noexcept (C++11)
Exceptions
Espaces de noms
Types
spécificateur decltype (C++11)
Qualificatifs
qualificatifs const et volatile
qualificatifs de stockage
qualificatif constexpr (C++11)
qualificatif auto (C++11)
qualificatif alignas (C++11)
Initialisation
Littéraux
Expressions
opérateurs alternatifs
Utilitaires
Types
déclaration typedef
déclaration d'alias de type (C++11)
attributs (C++11)
Jette
Original:
Casts
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
conversions implicites
conversion const_cast
conversion static_cast
conversion dynamic_cast
conversion reinterpret_cast
conversions style C et style fonction
Allocation de mémoire
Classes
Qualificatifs spécifiques aux membres de classe
Fonctions membres spéciales
Modèles
classes génériques
fonctions génériques
spécialisation de modèles
paquets de paramètres (C++11)
Divers
Assembleur
 
Convertit en toute sécurité pointeurs et les références à des classes de haut en bas et de côté le long de la hiérarchie d'héritage .
Original:
Safely converts pointers and references to classes up, down, and sideways along the inheritance hierarchy.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Sommaire

[modifier] Syntaxe

dynamic_cast < new_type > ( expression )
Renvoie une valeur de type de new_type ou lève une exception .
Original:
Returns a value of type new_type or throws an exception.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Explication

Seules les conversions suivantes peut être fait avec dynamic_cast, sauf lorsque de telles conversions jetterait sans constante''' ou la volatilité .
Original:
Only the following conversions can be done with dynamic_cast, except when such conversions would cast away constness or volatility.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
Si le type de expression est le new_type exactement ou une version moins cv-qualifié de new_type, le résultat est expression .
Original:
If the type of expression is the exactly new_type or a less cv-qualified version of new_type, the result is expression.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
Si la valeur de expression est la valeur de pointeur NULL, le résultat est la valeur de pointeur nul new_type type
Original:
If the value of expression is the null pointer value, the result is the null pointer value of type new_type
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
Si new_type est un pointeur ou une référence à Base, et le type de expression est un pointeur ou une référence à Derived, où Base est unique, la classe de base accessible de Derived, le résultat est un pointeur ou une référence à la sous-objet de classe Base dans le Derived objet pointu ou identifié par expression. (Note: conversion implicite et static_cast pouvez effectuer cette conversion ainsi)
Original:
If new_type is a pointer or reference to Base, and the type of expression is a pointer or reference to Derived, where Base is a unique, accessible base class of Derived, the result is a pointer or reference to the Base class subobject within the Derived object pointed or identified by expression. (note: implicit cast and static_cast can perform this conversion as well)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
4)
Si expression est un pointeur ou une référence à un type polymorphe, et new_type est un pointeur vers void, le résultat est un pointeur vers l'objet le plus dérivé pointu ou référencé par expression .
Original:
If expression is a pointer or reference to a polymorphic type, and new_type is a pointer to void, the result is a pointer to the most derived object pointed or referenced by expression.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
5)
Si expression est un pointeur ou une référence à un type polymorphe Base et new_type est un pointeur ou une référence au type Derived un chèque moment de l'exécution est effectuée:
Original:
If expression is a pointer or reference to a polymorphic type Base, and new_type is a pointer or reference to the type Derived a run-time check is performed:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
a)
L'objet le plus dérivé signalé / identifié par expression est examinée. Si, dans cet objet, les points expression / référés à une base publique de Derived, et si un seul sous-objet de type Derived est dérivé du sous-objet pointu / identifié par expression, le résultat des points fonte / se réfère à ce sous-objet Derived. (C'est ce qu'on appelle la «abattu»)
Original:
The most derived object pointed/identified by expression is examined. If, in that object, expression points/referes to a public base of Derived, and if only one subobject of Derived type is derived from the subobject pointed/identified by expression, then the result of the cast points/refers to that Derived subobject. (this is known as the "downcast")
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
b)
Sinon, si des points expression / désigne une base publique de l'objet le plus dérivée, et, simultanously, l'objet le plus dérivé a une classe de base sans ambiguïté publique de Derived type, la suite des points de casting / renvoie à ce Derived (c'est ce qu'on appelle comme le "buttées")
Original:
Otherwise, if expression points/refers to a public base of the most derived object, and, simultanously, the most derived object has an unambiguous public base class of type Derived, the result of the cast points/refers to that Derived (this is known as the "sidecast")
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
c)
Dans le cas contraire, le chèque d'exécution échoue. Si le dynamic_cast est utilisé sur les pointeurs, la valeur de pointeur nul new_type type est retourné. Si elle a été utilisée sur des références, le std::bad_cast exception est levée .
Original:
Otherwise, the runtime check fails. If the dynamic_cast is used on pointers, the null pointer value of type new_type is returned. If it was used on references, the exception std::bad_cast is thrown.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
6)
Lorsque dynamic_cast est utilisé dans un constructeur ou un destructeur (directement ou indirectement), et expression référence à l'objet qui est actuellement en cours de construction / destruction, l'objet est considéré comme l'objet le plus dérivé. Si new_type n'est pas un pointeur ou une référence à / destructeur de la construction propre classe ou une de ses bases, le comportement est indéfini .
Original:
When dynamic_cast is used in a constructor or a destructor (directly or indirectly), and expression refers to the object that's currently under construction/destruction, the object is considered to be the most derived object. If new_type is not a pointer or reference to the construction's/destructor's own class or one of its bases, the behavior is undefined.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Semblable à d'autres expressions de transtypage, le résultat est le suivant:
Original:
Similar to other cast expressions, the result is:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  • une lvalue si new_type est un type lvalue de référence (expression doit être une lvalue)
    Original:
    an lvalue if new_type is an lvalue reference type (expression must be an lvalue)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • un xValue si new_type est un type de référence rvalue (expression peut être lvalue rvalue ou)
    Original:
    an xvalue if new_type is an rvalue reference type (expression may be lvalue or rvalue)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • prvalue un autre (dans ce cas, si new_type est un type pointeur)
    Original:
    a prvalue otherwise (in this case, if new_type is a pointer type)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

[modifier] Note

Downcast peut également être effectuée avec static_cast, ce qui évite le coût de la vérification de l'exécution, mais c'est seulement en sécurité si le programme ne peut garantir, par une autre logique, que l'objet pointé par expression est certainement Derived .
Original:
Downcast can also be performed with static_cast, which avoids the cost of the runtime check, but it's only safe if the program can guarantee, through some other logic, that the object pointed to by expression is definitely Derived.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Mots-clés

dynamic_cast

[modifier] Exemple

#include <iostream>
 
struct V {
    virtual void f() {};  // must be polymorphic to use runtime-checked dynamic_cast
};
struct A : virtual V {};
struct B : virtual V {
  B(V* v, A* a) {
    // casts during construction
    dynamic_cast<B*>(v); // well-defined: v of type V*, V base of B, results in B*
    dynamic_cast<B*>(a); // undefined behavior: a has type A*, A not a base of B
  }
};
struct D : A, B {
    D() : B((A*)this, this) { }
};
 
struct Base {
    virtual ~Base() {}
};
 
struct Derived: Base {
    virtual void name() {}
};
 
int main()
{
    D d; // the most derived object
    A& a = d; // upcast, dynamic_cast may be used, but unnecessary
    D& new_d = dynamic_cast<D&>(a); // downcast
    B& new_b = dynamic_cast<B&>(a); // sidecast
 
 
    Base* b1 = new Base;
    if(Derived* d = dynamic_cast<Derived*>(b1))
    {
        std::cout << "downcast from b1 to d successful\n";
        d->name(); // safe to call
    }
 
    Base* b2 = new Derived;
    if(Derived* d = dynamic_cast<Derived*>(b2))
    {
        std::cout << "downcast from b2 to d successful\n";
        d->name(); // safe to call
    }
 
    delete b1;
    delete b2;
}

Résultat :

downcast from b2 to d successful

[modifier] Voir aussi