C++ otomatik tip dökümü: Bir kapsayıcı sınıfı için yanlış davranış

Question

Çok küçük sabit büyüklükteki vektörler ve matrisler üzerinde doğrusal cebir işlemleri için bazı sınıfları uygularım. CurrentY, var olduğunda:

MyMathVector<int, 3> a ={1, 2, 3}; 
MyMathVector<double, 3> b ={1.3, 2.3, 3.3}; 
std::cout<<"First = "<<a+b<<std::endl; 
std::cout<<"Second = "<<b+a<<std::endl; 

sonra First = {2, 4, 6} ve Second = {2.3, 4.3, 6.3}, ikinci eleman derleyici tarafından birinci eleman türüne döküm olduğu için. Yerli C++ ile aynı tür otomatik döküm sağlamak için herhangi bir "kolay" yolu var mı: int + double = double, double + int = double?

Çok teşekkür ederim.

DÜZENLEME: Yanıtlardan verilen sözdizimi ile, operatör + çalışanı aldım. Ama aşağıdaki sözdizimini çalıştı ve derleme hatası ile başarısız: expected a type, got ‘std::common_type<T, TRHS>::type’

#include <iostream> 
#include <type_traits> 

template<class T> class MyClass 
{ 
    public: 
     MyClass(const T& n) : _n(n) {;} 
     template<class TRHS> MyClass<typename std::common_type<T, TRHS>::type> myFunction(const MyClass<TRHS>& rhs) 
     { 
      return MyClass<std::common_type<T, TRHS>::type>(_n*2+rhs._n); 
     } 
     T _n; 
}; 

int main() 
{ 
    MyClass<double> a(3); 
    MyClass<int> b(5); 
    std::cout<<(a.myFunction(b))._n<<std::endl; 
} 

o sözdizimi sorunu nedir?

Answer 1

kullanımı std::common_type:

elemanı fonksiyonu durumunda

template <std::size_t s, typename L, typename R> 
MyMathVector<typename std::common_type<L, R>::type, s> operator+(MyMathVector<L, s> const& l, MyMathVector<R, s> const& r) 
{ 
    // do addition 
} 

Ot (sınıf gövdesi, T ve s görebilir olarak)

template <typename TRHS> 
MyMathVector<typename std::common_type<T, TRHS>::type, s> operator+(MyMathVector<TRHS, s> const& rhs) const 
{ 
    // do addition 
} 

Answer 2

kullanımlar std::common_type özellik anlamaya Karma işlem için doğru sonuç türü.

Bağlantılı sayfanın davanıza çok benzer bir örneği var.

Answer 3

Kesinlikle; decltype kullanın:

template<typename Other> 
auto operator+(const MyMathVector<Other, size> &other) 
    -> MyMathVector<decltype(std::declval<T>() + std::declval<Other>()), size>; 

üye olmayan bir operatör olarak, aslında bir vektör elemanı başvurarak ne anlama geldiğini söylemek daha iyi olabilir:

template<typename size, typename L, typename R> 
auto operator+(const MyMathVector<L, size> &l, const MyMathVector<R, size> &r) 
    -> MyMathVector<decltype(l[0] + r[0]), size>;