Bir static_cast gerçekleştirmek zaman ben bir assert olsun ki ben şu şablonu oluşturduk

Question

Uzun zaman önce bir referans statik döküm İşaretli ama tip I olmasını farz ne değildir: istediğim

/// 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); 
} 

Bugün

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

ancak derleyici başka referans bir başvuru döküm ediyorum bu aşırı kullanmak görünmüyor: yanı işaretçiler ile ancak referanslarla sadece çalışacak bir varyantı oluşturmak için. Korkarım ki nedenini anlamak ya da çalışan bir varyant yaratabilmek için şablon çözünürlük kurallarını anlamıyorum.

Not: Bu proje için istisnalar devre dışı bırakıldığı için dynamic_cast<Type *> NULL yerine bad_cast exception'u yakalayamıyorum.

Answer 1

Kaldır * ve &:

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

DÜZENLEME:

/// 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); 
} 

Sonra istenen sözdizimi kullanılabilir işaretçi tipi dönüşüm ekledi.

Answer 2

aşağıdaki deneyin:

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

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

Daha sonra, her işaretçi birinci varyantı kullanmak ve her referans kısmi uzmanlık (IIRC) kurallarına de ikinci kullanır.

Answer 3

Bu çalışır:

/// 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); 
} 

böyle kullanın:

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

Bu çözüm fonksiyon şablonları aşırı güvenir. Çözümünüz işe yaramadı çünkü ilk şablonunuz çok genel, zaten ikinci fonksiyonunuzu içeriyor. Fonksiyon şablonları için uzmanlık olmadığını unutmayın! Sadece sınıf şablonlarını özelleştirebilirsiniz. dönüş türlerinden

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); 
} 

Bu uygulama std-lib gelen static_cast veya dynamic_cast gibi çalışır: ``

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