当操作数类型为 short 时编译模板标量向量加法运算符失败

Question

我在简单向量中使用 auto、decltype 和 declval class 以执行基本的向量操作，例如添加一个标量和一个向量。但是，在尝试添加一个短类型的标量和一个短类型的向量时，我无法让它工作。

// Vector.h
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
using namespace std;

template<typename T> class Vector;
template<typename T> std::ostream& operator<< ( std::ostream& s, const Vector<T>& other );

template<typename T>
class Vector {
  std::vector<T> base;

  // vector + scalar
  template<typename T1, typename T2>
  friend auto operator+(const Vector<T1> & lhs, const T2 & scalar) -> Vector<decltype(std::declval<T1>() + std::declval<T2>())>;         

  friend std::ostream& operator<< <T> ( std::ostream& s, const Vector<T>& other );

public:
  Vector();
  Vector( const Vector<T>& other );
  Vector<T>& operator= ( const Vector<T> &other );
  auto& operator[] ( int i );
  void insert( const T element );
};

template<typename T>
Vector<T>::Vector() {
}

template<typename T>
Vector<T>::Vector( const Vector<T>& other ) {
  base = other.base;
}

template<typename T>
Vector<T>& Vector<T>::operator= ( const Vector<T> &other ) {
  base = other.base;
}

template<typename T>
auto& Vector<T>::operator[] ( int i ) {
  assert( i >= 0 && i < base.size() );
  return base[i];
}

template<typename T>
void Vector<T>::insert( const T element ) {
  base.push_back( element );
}

// vector + scalar
template<typename T1, typename T2>
auto operator+(const Vector<T1> & lhs, const T2 & scalar)
  -> Vector<decltype(std::declval<T1>() + std::declval<T2>())>
{
  typedef decltype(std::declval<T1>() + std::declval<T2>()) T3;
  Vector<T3> result;
  result.base.reserve(lhs.base.size());
  std::transform(lhs.base.begin(), lhs.base.end(), std::back_inserter(result.base),
                 [&scalar](const T1 & element) { return element + scalar; });
  return result;
}

测试程序：

// vector_test.cpp

void test_vector_int_scalar_int_addition() {
  Vector<int> v;
  v.insert( 1 );
  v.insert( 2 );
  v.insert( 3 );
  int s = 2;
  Vector<int> res = v + s;
  }

void test_vector_short_scalar_short_addition() {
   Vector<short> v;
   v.insert( 1 );
   v.insert( 2 );
   v.insert( 3 );
   short s = 2;
   Vector<short> res = v + s;
}

int main() {
   test_vector_int_scalar_int_addition(); // Compiles and works
   test_vector_short_scalar_short_addition(); // Does NOT compile
}

在使用 short "test_vector_short_scalar_short_addition()" 的情况下编译上述代码失败，但在使用 int "test_vector_int_scalar_int_addition()" 时工作正常。我收到以下错误：

 error: no viable conversion from 'Vector<decltype(std::declval<short>() + std::declval<short>())>' to 'Vector<short>'

令我困惑的是它对其他类型也能正常工作，例如double、float、long 等，但似乎在使用 short.

时仅失败

编译器信息：

clang++ --version
Apple LLVM version 6.1.0 (clang-602.0.53) (based on LLVM 3.6.0svn)

Answer 1

内置加法运算符的操作数经过通常的算术转换，其中包括整数提升，这意味着大多数整数整数转换级别小于 int 的类型将转换为 int.

上面的意思是你的Vector<decltype(std::declval<short>() + std::declval<short>())>其实是Vector<int>，编译器报错不能转换成Vector<short>.

这可以使用以下代码验证：

#include <iostream>
#include <type_traits>

int main()
{
    std::cout << std::is_same<decltype(std::declval<short>() + std::declval<short>()), int>::value << '\n';
}

打印 1.

作为确定结果类型的替代方法，您可以考虑 std::common_type。如果两个操作数都是 short，这将为您提供 short，但如果类型不同，则仍会应用 通常的算术转换 - 例如，unsigned short 和 short 通常会产生 int（如果 sizeof(short) < sizeof(int)）。

Answer 2

上述行为可以通过这个简单的例子重现：

short a = 1, b = 1;
auto res = a + b; // decltype(res) == int

作为常规算术转换的一部分，两个操作数 (shorts) 都经过整数提升并转换为 int。 float 或 double 不是这种情况，因为它们是浮点类型。由于short的秩小于int，所以运算结果转为int，如果可以。

http://en.cppreference.com/w/c/language/conversion#Usual_arithmetic_conversions

当操作数类型为 short 时编译模板标量向量加法运算符失败

Compiling template scalar vector addition operator when operands are of type short fails

c++

templates

decltype

auto

c++14