12
votes

Cast dynamique travaillant sur des types non liés

#include <iostream> 
using namespace std; 
class X{ 
     public: 
     virtual void f(){} 
}; 

class Y { 
     public: 
     virtual void g() {} 
}; 

int main() 
{ 
     X * x = new X(); 
     Y* y = dynamic_cast<Y*>(x); //A 
     // Y* y = static_cast<Y*>(x);  //B 
     cout << y << endl; 
} 
A compiles whereas B doesn't. I understand why B doesn't get compiled but why does A get compiled although X and Y are completely unrelated types?

c++ inheritance

0 commentaires

7 Réponses :

1
votes

compilateur s'en fiche, car il est dynamic_cast . y sera null après la distribution.



                                                                    
                                    
                                    
                                        0 commentaires


                        
                                            
                            
                                
                                    5
 votes
                                
                            
                            
                                
                                     La distribution dynamique utilise les informations de type d'exécution. C'est donc légal faire ce cas mais il retournera un pointeur nul.
La distribution statique est évaluée par le compilateur.                                 

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                      dynamic_cast  exécute le type de vérification de l'exécution, à l'aide de RTTI, tandis que  static_cast  fonctionne au moment de la compilation. Alors, que vous obtiendriez si vous avez couru  a  serait  y == null . 

 Je vous suggère de  Lisez  sur C ++ Type Casts.                                 


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Cast dynamique retourne null s'il ne peut pas terminer la distribution: 

  http://www.cplusplus.com/doc/tatutorial/typecasting/ 

 et rechercher dynamic_cast                                 

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Si [en utilisant Dynamic Cast], vous essayez de lancer sur un type de pointeur et que le type n'est pas un type réel de l'objet d'argument, le résultat de la distribution sera  null . < Pré> xxx                                  

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    25
 votes
                                
                            
                            
                                
                                     C'est pourquoi  dynamic_cast  est autorisé entre types non liés:  xxx                                  


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Il y a une différence énorme entre  static_cast  code> et  dynamic_cast  code>, je vais simplement réduire la discussion au monde des objets. 
 A  static_cast  code > Peut être utilisé pour le casting (infâme). C'est-à-dire:  p>  xxx  pré> 
 Le compilateur peut déterminer si cela est légal ou non, car avoir la définition de  dérivée  code> it  sait  forte > si  dérivé  code> est en fait une descendante de  base  code>.  p> 
 pour les hiérarchies non triviales:  p>  xxx  pré > 
 Cela donnerait une erreur: le compilateur ne saurait pas à partir de quelle base (celle de  d1  code> ou celle de  d2  code> vous êtes venu de). / p> 
 ou si vous avez utilisé  virtuel  code> héritage:  p>  xxx  pré> 
 Le compilateur aurait besoin d'informations d'exécution et la compilation échouerait donc aussi.  p> 
 A  dynamic_cast  code> est cependant beaucoup plus intelligent, bien que cela arrive au coût des frais généraux d'exécution. Le compilateur génère des informations sur les objets connus comme RTTI (informations de type d'exécution), que le  dynamic_cast  code> explorera pour permettre:  p> 
 couler en fonction du type de temps d'exécution véritable:  P > 
void foobar(X* x)
{
   void* xAddr = dynamic_cast<void*>(x);

   Y* y = dynamic_cast<Y*>(y);
   void* yAddr = dynamic_cast<void*>(y);

   Z* z = dynamic_cast<Z*>(x);
   void* zAddr = dynamic_cast<void*>(z);
   if (z) { assert(xAddr == yAddr && xAddr == zAddr); }
}

                                

                                                                    
                                    
                                    
                                        0 commentaires