Şablon operatör yüklenmesinde aşırı yüklenme yok

Question

Üzgünüz, bu genel bir soru gibi görünüyor, aradığım yanıtın cevabını bulana kadar bulamadım. En yakın sonrası olacağını bu bir: Template Specialization for basic POD only

ı bir sınıf template <class T> class A {...}; var ve ben bir iç ikili operatör (tip A iki nesne) olarak operatör + aşırı istiyoruz ve tip karma bir ikili operatör olarak (nesne diyelim A ve sayısal POD tipi).

#include <type_traits> 
using namespace std; 

// Declare/fine template 
template <class T> class A {...}; 

// Internal binary operator 
template < class T, class U > 
    A< typename common_type<T,U>::type > 
operator+ (const A<T> &a, const A<U> &a) { ... } 

// Mixed binary operator 
template < class T, class U > 
    A< typename common_type<T,U>::type > 
operator+ (const A<T> &a, const U &b) { ... } 

Ama ikinci tanım ilkinden çatışma halinde olduğu gibi o zaman görünüyor:

İdeal olarak, yazdıklarıma istiyorum olduğunu. İkinci tanımı kullanarak, U'nun sayısal bir POD tipi olduğundan emin olmanın yolunu biliyorum. Eğer bu şekilde gidersem sorun şu ki, eğer temelde A şablonunda bulunan altta yatan şablon tipinin ne olduğunu bilmemizin bir yolu yok.

Lütfen bana sorumun yeterince açık olup olmadığını söyle ve şimdiden teşekkürler! :)

DÜZENLEME: Şablon belirtimi, son filtremde "A<T> ise U" ifadesiyle silinmiştir. Kısacası, T'nin saklı olduğunu söylüyorum. Bu hemen canlı kümesinden ikinci aşırı dışlar

#include <type_traits> 


// "A" template  

template <typename> class A {}; 


// Traits for "A-ness": 

template <typename> struct is_a : std::false_type { }; 
template <typename T> struct is_a<A<T>> : std::true_type { }; 


// Operators: 

template <class T, class U> 
A<typename std::common_type<T, U>::type> 
operator+(const A<T> & a, const A<U> & b); 

template <class T, class U, 
      typename = typename std::enable_if<!is_a<U>::value>::type> 
A<typename std::common_type<T, U>::type> 
operator+(const A<T> & a, const U & b); 

ve getiri belirleme yüzden sorun:

Answer 1

Bunu daha genel türlerinden A ait uzmanlık ayırt etmek için bir küçük yardımcı özelliği ile çalışmak yapabilirsiniz İkinci aşırı yükün türü, sadece ilk istendiğinde asla ortaya çıkmaz.

(Bu aşırı yük setini kontrol etmek temerrüde şablon argümanları içinde enable_if kullanarak bir örnektir.)

Answer 2

Sen common_type bir SFINAE dostu yazabilirsiniz - Kampta şahsen olduğumu özellikler gerektiği hemen her zaman SFINAE . Şöyle ki:

Şimdi

// Black hole metafunction that eats everything 
template<typename...> struct void_ { using type = void; }; 

template<typename... T> 
using Void = typename void_<T...>::type; 

// Due to std::common_type being variadic we need to 
// pass a variadic pack around 
template<typename... T> struct list {}; 

// Actually defined, but with no member types for SFINAE purposes 
template<typename Sequence, typename Sfinae = void> 
struct common_type_impl {}; 

template<typename... T> 
struct common_type_impl<list<T...>, Void<typename std::common_type<T...>::type>> 
: std::common_type<T...> {}; 

template<typename... T> struct common_type: common_type_impl<list<T...>> {}; 

, aşırı yük yerine gürültüyle şikayet adaylar listesinden silinecektir A<T> ve U arasında hiçbir ortak türü yoktur.

Ayrıca, DR 2141 numaralı belgede belgelendiği gibi, kendi başına sorunları olan sonuç olarak, std::common_type'u değiştirmek de mümkündür. Değiştirmeyi özetlemeyeceğim çünkü daha iyi bir çözümün ne olduğu belli değil, özellikle de DR'nin önerilen çözümünün daha kötü olduğunu düşünüyorum.