Contrôlé fonte statique sur une référence

Question

Il y a longtemps que je l'ai créé un modèle suivant pour que je sois un assert chaque fois que je joue un static_cast mais le type est pas ce que je suppose qu'il soit:

/// perform a static_cast asserted by a dynamic_cast 
template <class Type, class SourceType> 
Type static_cast_checked(SourceType item) 
{ 
    Assert(!item || dynamic_cast<Type>(item)); 
    return static_cast<Type>(item); 
} 

Aujourd'hui, je voulais pour créer une variante qui ne fonctionnerait pas seulement avec des pointeurs, mais avec des références ainsi:

/// overload for reference 
template <class Type, class SourceType> 
Type &static_cast_checked(SourceType &item) 
{ 
    Assert(dynamic_cast<Type *>(&item)); 
    return static_cast<Type>(item); 
} 

Cependant, le compilateur ne semble pas utiliser cette surcharge lorsque je cASTING une référence à une autre référence. J'ai peur de ne pas comprendre suffisamment les règles de résolution des templates pour comprendre pourquoi ou pour créer une variante qui fonctionne.

Remarque: Je ne peux pas attraper le bad_cast exception au lieu de vérifier dynamic_cast<Type *> pour NULL, les exceptions étant désactivées pour ce projet.

Answer 1

Supprimer * et & des types de retour:

/// perform a static_cast asserted by a dynamic_cast 
template <class Type, class SourceType> 
Type static_cast_checked(SourceType *item) 
{ 
    Assert(!item || dynamic_cast<Type>(item)); 
    return static_cast<Type>(item); 
} 

template <class Type> struct make_pointer 
{ 
    typedef Type *PointerType; 
}; 

template <class Type> struct make_pointer<Type &> 
{ 
    typedef Type *PointerType; 
}; 

/// overload for reference 
template <class Type, class SourceType> 
Type static_cast_checked(SourceType &item) 
{ 
    Assert(dynamic_cast<typename make_pointer<Type>::PointerType>(&item)); 
    return static_cast<Type>(item); 
} 

Ensuite, vous pouvez utiliser votre syntaxe désirée:

Derived *d= static_cast_checked<Derived *>(b); 
Derived &d= static_cast_checked<Derived &>(b); 

EDIT: Ajout d'une conversion de type pointeur.

Answer 2

les opérations suivantes:

template<class Type, class SourceType> 
Type* static_cast_checked(SourceType* item) 
{ 
    // ... 
} 

template<class Type, class SourceType> 
Type& static_cast_checked(SourceType& item) 
{ 
    // ... 
} 

Ensuite, chaque pointeur utiliserait la première variante et chaque référence utilisera la deuxième aux règles de spécialisation partielle (IIRC).

Answer 3

Cela fonctionne:

/// perform a static_cast asserted by a dynamic_cast 
template <class Type, class SourceType> 
Type* static_cast_checked(SourceType *item) 
{ 
    Assert(!item || dynamic_cast<Type*>(item)); 
    return static_cast<Type*>(item); 
} 

/// overload for reference 
template <class Type, class SourceType> 
Type &static_cast_checked(SourceType &item) 
{ 
    Assert(dynamic_cast<Type *>(&item)); 
    return static_cast<Type&>(item); 
} 

utiliser comme ceci:

Dervied d; 
Base* pbase = static_cast_checked<Base>(&d); 
Base& rbase = static_cast_checked<Base>(d); 

Cette solution repose sur la surcharge des modèles de fonction. Votre solution n'a pas fonctionné car votre premier modèle est trop général, il inclut déjà votre deuxième fonction. Notez qu'il n'y a pas de spécialisation pour les modèles de fonction! Vous pouvez uniquement spécialiser les modèles de classe.

Answer 4

#include <boost/type_traits/add_pointer.hpp> 

template <class Type, class SourceType> 
Type static_cast_checked(SourceType *item) 
{ 
    assert(!item || dynamic_cast<Type>(item)); 
    return static_cast<Type>(item); 
} 

template <typename Type, class SourceType> 
Type static_cast_checked(SourceType &item) 
{ 
    typedef typename boost::add_pointer<Type>::type TypePtr; 
    assert(dynamic_cast<TypePtr>(&item)); 
    return static_cast<Type>(item); 
} 

Cette implémentation fonctionne comme static_cast ou dynamic_cast du std-lib: ``

Base &b = static_cast_checked<Base&>(a); 
    Base* bPtr = static_cast_checked<Base*>(&a);