Neden benim templated işlevi 'T', 'T', 'T' = 'double' teşvik eder?

Question

typename T ile şablonlanmış bir sınıf var. Bu örnek

sorunum yok

myClass<double, 2> myObj_double_2(constructor args); 
myObj_double_2 = myObj_double_2 + 5.2; 

için ben bu çağrı bir işlevi,

template <typename T, size_t a> 
myClass<T,a> operator+(myClass<T,a> lhs, const T& rhs) { 
    return lhs += rhs; 
} 

myClass<T,a> myClass<T,a>::operator+=(const T& rhs) { 
    // Do addition, depends on 'a'. 
    return *this; 
} 

içerir.

Ben ancak

myObj_double_2 = myObj_double_2 + 5; 

Sonra derleyici bana böyle bir mesaj verir çağırırsanız - No match for 'operator+' (operand types are 'myClass<double, 2ul>' and 'int'). Candidates are ... note: deduced conflicting types for parameter 'const T' ('double' and 'int').

Kodu, T'a dönüşen ek türlerin geçirilmesine izin vermek için bir şekilde yazabilir miyim (örneğin, çift (5) geçerli bir yapıcı çağrısıdır)?

Answer 1

, bir şablon parametresi için tüm kesintiler aynı sonucu olması gerekir.

Sizin durumunuzda, T için iki kesinti, double ve int üretir; bunlar aynı değildir ve kesinti başarısız olur.

sadece şablon argümanı kesinti için bir fonksiyon argüman kullanmak, diğeri undeduced yapmak olduğunu yapabilecekleriniz: std::common_type<T>::type, esasen sadece T olduğunu

template <typename T, std::size_t A> 
void foo(myClass<T, A> arg1, typename std::common_type<T>::type arg2); 
//       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

Not olduğunu ancak türüne nedeniyle arg2 artık bağımlı bir tür (adı, ::'un sağında görünür), sonuç çıkarılmaz. Bu nedenle, yalnızca ilk argüman kesintide yer alır ve T = double açık bir şekilde üretir ve ardından ikinci işlev parametresi yalnızca double türüne sahiptir ve normal dönüşümler gerçekleşir.

Genel kural olarak, şablon argümanı indirimi ::'u geçmez.

Answer 2

aşırı yük çözünürlüğüne derleyici zaten double için mahsup ediliyor operator+ çünkü T için doğru bir aday bulmak için başarısız olur ve edebi 5 bir tam sayıdır. Çözüm: şablon argümanı kesinti kullanırken

template <typename T1, typename T2, size_t a> 
myClass<T1,a> operator+(myClass<T1,a> lhs, const T2& rhs) { 
    return lhs += T1(rhs); 
} 

Answer 3

Şablon türü kesintisi ile ilgili sorunlara yol açıyorsunuz.

her iki bağımsız değişkeni T değerini deducing zaman "eşit ayakta" verilir ve iki argüman katılmıyorum bu durumda olan - bir başka Tdouble olması gerektiğini söylüyor, Tint olacağını söylüyor.

Bunu düzeltmenin doğru yolu Koenig operatörleriyle yapılır.

Yap += ve + ve sınıfın gibi friend ler ve inline uygulamak:

template<class T, size_t a> 
class myClass { 
    // etc 
public: 
    friend myClass operator+(myClass lhs, const T& rhs) { 
    lhs += rhs; 
    return std::move(lhs); 
    } 
    friend myClass& operator+=(myClass& lhs, const T& rhs) { 
    // do addition, depends on `a` 
    return *this; 
    } 
}; 

bu teknik garip bir şey yapar. Sınıfın şablon türüne bağlı olarak template operatörünü oluşturur. Bunlar daha sonra, + veya +='u çağırdığınızda, ADL (Koenig araması) aracılığıyla bulunur.

Şablon operatörü başına bu işleçlerden birini alırsınız, ancak şablon operatörleri değildir, bu nedenle const T& sonuçlandırılmamıştır ve dönüşüm beklendiği gibi gerçekleşir.