Question

我在简单的向量类中使用auto，decltype和declval，以便执行基本的向量操作，例如添加标量和矢量。但是，在尝试添加short类型和short类型的向量时，我无法使其工作。

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

使用简短的“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

作为通常的算术转换的一部分，两个操作数（int s）都经过整数提升并转换为float。 double或short不是这种情况，因为它们是浮点类型。由于int的排名小于int的排名，因此如果，则操作的结果将转换为{{1}}。

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

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

2 个答案: