Question

这样的事情可能吗？

// We can even assume T and U are native C++ types
template<typename T, typename U>
magically_deduce_return_type_of(T * U) my_mul() { return T * U; }

或者有人必须破解一个return_type结构并为每对原生类型专门化它？

Answer 1

听说decltype？

在C++0x你可以做

template<class T, class U>
auto mul(T x, U y) -> decltype(x*y)
{
    return x*y;
}

Answer 2

您可以使用非C++0x代码执行此操作：

template<typename T, typename U> class Mul
{
  T t_;
  U u_;
public:
  Mul(const T& t, const U& u): t_(t), u_(u) {}
  template <class R>
  operator R ()
  {
    return t_ * u_;
  }
};

template<typename T, typename U>
Mul<T, U> mul(const T& t, const U& u)
{
  return Mul<T, U>(t, u);
}

使用方法： char t = 3; 短u = 4; int r = mul（t，u）;

这里我们有两种类型的扣除。我们通过用法隐式声明返回类型，而不是decltype（T * U）

Answer 3

我正在使用Visual Studio 2008，因此我不得不想出一种非C ++ 0x方式。我最终做了这样的事情。

template<typename T> struct type_precedence { static const int value = -1; };
template< > struct type_precedence<long double> { static const int value = 0; };
template< > struct type_precedence<double> { static const int value = 1; };
template< > struct type_precedence<float> { static const int value = 2; };
template< > struct type_precedence<unsigned long long> { static const int value = 3; };
template< > struct type_precedence<long long> { static const int value = 4; };
template< > struct type_precedence<unsigned long> { static const int value = 5; };
template< > struct type_precedence<long> { static const int value = 6; };
template< > struct type_precedence<unsigned int> { static const int value = 7; };
template< > struct type_precedence<int> { static const int value = 8; };
template< > struct type_precedence<unsigned short> { static const int value = 9; };
template< > struct type_precedence<short> { static const int value = 10; };
template< > struct type_precedence<unsigned char> { static const int value = 11; };
template< > struct type_precedence<char> { static const int value = 12; };
template< > struct type_precedence<bool> { static const int value = 13; };

/////////////////////////////////////////////////////////////////////////////////////////

template<typename T, typename U, bool t_precedent = ((type_precedence<T>::value) <= (type_precedence<U>::value))>
struct precedent_type { 
    typedef T t; 
};
template<typename T, typename U>
struct precedent_type<T,U,false> { 
    typedef U t;
};

/////////////////////////////////////////////////////////////////////////////////////////

template<typename T, typename U>
typename precedent_type<T,U>::t my_mul() { return T * U; }

编辑：这是一个例子 - 我实际上是这样做来乘以向量。它看起来像这样：

template<int N, typename T, typename U>
vec<N,typename precedent_type<T,U>::t> operator *(const vec<N,T>& v1,const vec<N,U>& v2) {
    ...
}

...

double3 = float3 * double3;
float4 = float4 * int4;
etc.

Answer 4

http://www2.research.att.com/~bs/C++0xFAQ.html#decltype

Answer 5

预的C ++ 0x

我不知道你想要完成什么，所以：

template<typename T, typename U>
void my_mul(T t, U u, bool& overflow) 
{
    my_mul_impl(t*u, overflow);
}

template<typename TmultU>
void my_mul_impl(TmultU mult, bool& overflow)
{
    //here you know the type and can do something meta-weird :)
    if(mult > type_traits<TmultU>::max_allowed_in_my_cool_program())
       overflow = true;
}

有more

为模板推导返回类型的运算符/函数

5 个答案: