c – 为不同的ref-qualifiers重载运算符的结果的类型特征

2023年5月26日 247次阅读

所以基本上我正在编写一个模板来确定表达式的类型(在这种情况下是dereference运算符)：

template<class T>
struct Asgard {

  template <class T>
  static auto check(T) -> decltype(*std::declval<T>()); // <-- the important line

  static utils::tt::SubstFailure check(...);

  using Dereference = decltype(check(std::declval<T>()));

};

但在网上看到一个例子后,它略有不同(here)：

template<class X>
static auto check(const X& x) -> decltype(x == x); // other operator, but not important.

它让我思考如果操作符为对象的不同限定符重载,那么我创建了一个测试类：

struct ThorsChariot {
  std::integral_constant<int, 1> operator*() const &{
    return std::integral_constant<int, 1>();
  }
  std::integral_constant<int, 2> operator*() & {
    return std::integral_constant<int, 2>();
  }
  std::integral_constant<int, 3> operator*() const &&{
    return std::integral_constant<int, 3>();
  }
  std::integral_constant<int, 4> operator*() && {
    return std::integral_constant<int, 4>();
  }  
};

我使用的以下符号基本上是指：

1 — the return type of a call on — const &
2                                  &
3                                  const &&
4                                  &&

以下是我测试的内容：

Asgard<const ThorsChariot>::Dereference
Asgard<ThorsChariot>::Dereference

Asgard<const ThorsChariot &>::Dereference
Asgard<ThorsChariot &>::Dereference

Asgard<const ThorsChariot &&>::Dereference
Asgard<ThorsChariot &&>::Dereference

我认为这些类型应该是(按顺序)(我使用n作为integral_constant< int,n>的快捷方式(参见上面关于符号的注释))：

1 2  1 2  3 4

以下是不同尝试的结果：

(A)
static auto check(T) -> decltype(*std::declval<T>()); 
4 4  4 4  4 4

(B)
static auto check(T t) -> decltype(*t);
2 2  2 2  2 2

(C)
static auto check(const T &t) -> decltype(*t);
1 1  1 1  1 1

(D)
static auto check(T &&t) -> decltype(*t);
1 2  1 2  1 2

(E)
static auto check(T &&t) -> decltype(*std::forward<T>(t));
static auto check(T &&) -> decltype(*std::declval<T>());
3 4 1 2 3 4

(C)和(D)我理解. (A)和(B)给我一些奇怪的结果.
我得到的最接近的是使用完美转发(E).它们适用于左值和右值类型,但是对于非引用类型,它会在rvalues上返回一个调用.为什么是这样？
有没有办法可以获得我想要的结果？我想要的是正确的吗？

我知道一个运算符为不同的限定符返回不同的类型不仅非常罕见,但可能是一种不好的做法,但这并不意味着我不必理解我观察到的行为.

最佳答案 你需要的是什么

(E)
static auto check(T &&t) -> decltype(*std::forward<T>(t));

和下降

Asgard<const ThorsChariot>::Dereference
Asgard<ThorsChariot>::Dereference

从你的测试中,因为它们没有意义(意思是,它们相当于相应的右值引用).这留给你1 2 3 4,这正是剩下的四个测试的结果.

请记住,std::declval<T>()始终添加&& amp;引用T,所以你得到的是一个右值引用,除非T是一个左值引用,在这种情况下你也得到一个左值引用. std::forward<T>()也发生了同样的事情：

template< class T >
typename std::add_rvalue_reference<T>::type declval();

template< class T >
T&& forward( typename std::remove_reference<T>::type& t );

template< class T >
T&& forward( typename std::remove_reference<T>::type&& t );

顺便说一句,你的测试比必要的复杂一点.您可以将T作为模板参数从Dereference传递给check,然后直接使用std :: declval< T>(),因此您不需要std :: forward< T>()：

template<class T>
struct Asgard {

  template <class T>
  static auto check(int) -> decltype(*std::declval<T>()); // <-- the important line

  template <class T>
  static utils::tt::SubstFailure check(...);

  using Dereference = decltype(check<T>(0));

};

(我认为也不需要int参数,但我现在没有测试).

现在,

returning different types for different qualifiers

现在可能很少见,但我认为这是一种很好的做法,我认为将来会更频繁.例如,请查看std::get,它可能是非成员函数,但可能同样是成员函数(不是出于技术原因,例如必须编写模板关键字). STL容器中的成员begin(),end()不是那样(还),我不知道它们是否以及何时会出现,但我相信这将是正确的方法.

我总是忽略const&& amp;因为我从未见过有用的用法,我想我记得读过Stroustrup说同样的话. rvalue引用的想法正是能够修改临时对象(这是有道理的,因为该对象可能包含对实际数据的指针或引用).因此似乎没有使用const&& const&不会完全一样.

在另一个极端,人们也可以考虑挥发性限定符的完整性,这提供了四个组合,将总数提高到八,这就是全部.但这更为罕见.

点赞