C++ 템플릿 자동 유형 프로모션

Question

template <class T> 
class Foo { 
public: 
    T val; 
    Foo(T _v): val(_v){} 
    friend ostream& operator<< (ostream& out, const Foo& A) { 
     out << A.val; 
     return out; 
    } 
}; 

template <class X, class Y> Foo<???> operator+(const Foo<X>& A, const Foo<Y> & B) { 
    if (sizeof(X) > sizeof (Y)) 
     return Foo<X>(A.val + B.val); 
    else 
     return Foo<Y>(A.val + B.val); 
} 

int main() { 
    Foo<double> a(1.5); 
    Foo<int> b(2); 
    cout << a << endl; 
    cout << b << endl; 
    cout << a+b << endl; 
} 

내 목표는 operator+ 함수가 인수의 유형에 따라 다른 유형을 반환하도록하는 것입니다. 예를 들어

, a은 int이고 하나 또는 둘 다이다 double 다음 Foo<double>을 리턴하는 경우, b는, ​​다음 Foo<int>int을 반환 경우.

할 수 있습니까?

Answer 1

사용 부분 템플릿 특수화 (C++ 03 또는 C++ 11).

// C++ does not allow partial specialization of function templates, 
// so we're using a class template here. 

template <typename X, typename Y, bool xLarger> 
struct DoPlusImpl // When x is selected 
{ 
    typedef Foo<X> result_type; 
}; 

template <typename X, typename Y> 
struct DoPlusImpl<X, Y, false> // When y is selected 
{ 
    typedef Foo<Y> result_type; 
}; 

template <typename X, typename Y> // Select X or Y based on their size. 
struct DoPlus : public DoPlusImpl<X, Y, (sizeof (X) > sizeof (Y))> 
{}; 

// Use template metafunction "DoPlus" to figure out what the type should be. 
// (Note no runtime check of sizes, even in nonoptimized builds!) 
template <class X, class Y> 
typename DoPlus<X, Y>::result_type operator+(const Foo<X>& A, const Foo<Y> & B) { 
    return typename DoPlus<X, Y>::result_type 
     (A.val + B.val); 
} 

현재 IDEOne에 대한 조치에서 볼 수 있습니다 ->http://ideone.com/5YE3dg

Answer 2

(C++ 11) dectype 내부 declval 식을 사용이 가능

#include <utility> 

template <class X, class Y> 
Foo<decltype(std::declval<X>() + std::declval<Y>())> operator+(...); 

Answer 3

예!

template <typename X, typename Y> struct Rule {}; 
template<> struct Rule<int, int> { typedef int type;}; 
template<> struct Rule<float, int> { typedef bool type;}; 

그런 다음

template <class X, class Y> Foo<typename Rule<X, Y>::type> operator+(...)