C++从函数返回两个模板参数中更精确的一个？

Question

我很好奇是否有任何方法可以在 C++ 中做到这一点。假设我有一个模板化向量类：

template <typename T>
class vector {          
public:
      vector(T a, T b, T c) : x(a), y(b), z(c) {}

      T x,y,z;
};

然后我有一个模板化加法运算符：

template <typename A, typename B> 
vector<A> operator +(const vector<A> &a, const vector<B> &b) { 
   return vector<A>(a.x+b.x, a.y+b.y, a.z+b.z); 
}

我很好奇是否可以修改该运算符，以便结果是两种类型 A 和 B 中更精确的一个，除了手动专门化它之外。

例如：

vector<float>       + vector<double> would produce a vector<double>, 
vector<long double> + vector<float>  would produce a vector<long double>

我的猜测是 C++ 中没有对此的自动支持，但我想我应该问一下。

Answer 1

没有任何库形式的内置支持，但您可以使用条件 (?:) 运算符来完成此操作。

在回复另一个答案时，Johannes Schaub 发布了 a promote template 很好地包装了逻辑。使用模板，您应该能够编写：

template <typename A, typename B>  
vector< typename promote<A, B>::type >
operator+(const vector<A> &a, const vector<B> &b) 
{     
    return vector< typename promote<A, B>::type >(a.x+b.x, a.y+b.y, a.z+b.z);  
} 

Answer 2

在 C++0x 中，您可以说：

template <typename A, typename B> 
auto operator +(const vector<A> &a, const vector<B> &b) -> vector<decltype(a.x + b.x)>
{
    //...
}

在 C++03 中，您需要自己定义所有组合，尽管您可以通过可重用的 op_traits 方案来完成，该方案可应用于各种不同的运营商。 James McNellis 在他的回答

Answer 3

Andrei Alexandrescu 在他 2001 年 4 月 1 日的 DDJ 文章 通用：最小和最大 Redivivus。

总之，总体问题非常复杂。

Andrei 使用了 80 行支持代码，这些代码又依赖于 Loki 库。

干杯&哈，.

Answer 4

有一种相对简单的方法可以使用模板专业化来做到这一点

 template< typename A >
 struct TypePrecision {
    static const int precisionLevel;
 };

 template< typename A >
 const int TypePrecision< A >::precisionLevel = 0;


 template<>
 struct TypePrecision< float > {
    static const int precisionLevel;
 };
template<>
 struct TypePrecision< long float > {
    static const int precisionLevel;
 };
  template<>
 struct TypePrecision< double > {
    static const int precisionLevel;
 };
template<>
 struct TypePrecision< long double > {
    static const int precisionLevel;
 };

 template<>
 const int TypePrecision< float >::precisionLevel = 1;
 template<>
 const int TypePrecision< long float >::precisionLevel = 2;
 template<>
 const int TypePrecision< double >::precisionLevel = 3;
 template<>
 const int TypePrecision< long double >::precisionLevel = 4;

然后您使用它来创建一个HigherPrecisionType，

 template < typename A , typename B >
 struct HigherPrecisionType
 { 
     static const int APrecision;
     static const int BPrecision;
 };

template < typename A , typename B >
const int HigherPrecisionType< A, B >::APrecision= TypePrecision< A >::precisionLevel;

template < typename A , typename B >
const int HigherPrecisionType< A, B >::BPrecision= TypePrecision< B >::precisionLevel;

但我不确定如何比较这些以获得专业化中的typedef到适当的类型。但我希望你明白

Answer 5

模式“类型选择”（在“现代 C++ 设计”中阅读）在这里可能很有用。

template <bool flag, typename T, typename U>
struct Select {
    typedef T Result;
};

template <typename T, typename U>
struct Select<false, T, U> {
    typedef U Result;
};

...

template <typename A, typename B> 
vector<Select<sizeof(A) > sizeof(B), A, B>::Result> operator +(const vector<A> &a, const vector<B> &b) { 
   return vector<Select<sizeof(A) > sizeof(B), A, B>::Result>(a.x+b.x, a.y+b.y, a.z+b.z); 
}

Answer 6

我选择尺寸更大的类型：

帮助模板：

template<bool b, typename A, typename B>
struct choose_if
{
    typedef A type;
};    
template<typename A, typename B>
struct choose_if<false, A, B>
{
    typedef B type;
};
template<typename A, typename B>
struct greater 
{
    static const bool value = sizeof(A) > sizeof(B);
    typedef vector<typename choose_if<value, A, B>::type> type;
};

现在使用它：

template <typename A, typename B> 
typename greater<A, B>::type operator +(const vector<A> &a, const vector<B> &b) 
{ 
    typedef typename greater<A, B>::type  type;
    return type(a.x+b.x, a.y+b.y, a.z+b.z); 
}

请参阅在线演示： http://www. ideone.com/PGyA8

Answer 7

您可以通过使用函数重载来实现您的目标。这意味着除了通用之外：

template <typename A, typename B> 
vector<A> operator +(const vector<A> &a, const vector<B> &b) { 
   return vector<A>(a.x+b.x, a.y+b.y, a.z+b.z); 
}

您还声明了特定类型的重载，然后使用这些重载而不是通用制造的重载：

vector<double> operator +(const vector<float> &a, const vector<double> &b) { 
   return vector<double>(a.x+b.x, a.y+b.y, a.z+b.z); 
}

您的另一个选择是在向量模板上实现所需类型的转换运算符。让浮点向量能够通过运算符返回双精度向量。

Answer 8

是的。这是 C++03 方法：

template < typename T1, typename T2 >
struct which_return;

template < typename T >
struct which_return<T,T> { typedef std::vector<T> type; };

template <  >
struct which_return<int,double> { typedef std::vector<double> type; };

template < >
struct which_return<double,int> : which_return<int,double> {};

// etc...
template < typename T1, typename T2 >
typename which_return<T1,T2>::type operator+ (std::vector<T1> const&, std::vector<T2> const&)
{
  // ...
}

显然，如果可以的话，您可以使用 C++0x 方法来实现。

Answer 9

C++11 引入了 std::common_type ，并且 C++14 引入了 std::common_type_t 因此您现在应该能够编写：

template <typename A, typename B> 
vector<std::common_type_t<A,B>::type> operator+(const vector<A> &a, const vector<B> &b) { 
   return vector<std::common_type_t<A,B>::type>(a.x+b.x, a.y+b.y, a.z+b.z); 
}

Answer 10

你永远无法完成这个：

vector; + 矢量<双>会产生一个向量，

而无需大量欺骗或返回指向您自己设计的某些小玩意的指针，因为operator+必须返回编译时已知的类型。您要求返回在运行时确定的类型。