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

Question

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

// 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>'

What puzzles me is that is works fine for other types e.g. double, float, long etc. but appears to fail only when using short.

Compiler info:

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) )。