所以基本上我正在编写一个模板来确定表达式的类型(在本例中为取消引用运算符):

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)。它们适用于左值和右值类型，但是对于非引用类型，它会返回对右值的调用。这是为什么？
有什么办法可以获得我想要的结果吗？我想要的是正确的吗？

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

最佳答案

你需要的是

(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>() 总是添加 &&引用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 例如，它可能是一个非成员函数，但同样可以是一个成员函数(这不是出于技术原因，例如必须编写 template 关键字)。成员(member)begin() , end()在 STL 容器中(目前)还不是这样，我不知道它们是否以及何时会是这样，但我相信这是正确的方法。

我总是忽略 const&& 的大小写因为我从未见过有意义的用法，而且我想我记得读过 Stroustrup 说过同样的话。右值引用的想法正是能够修改一个临时对象(这是有道理的，因为这个对象可能包含指向实际数据的指针或引用)。所以似乎没有用const&&其中 const&不会完全一样。

在另一个极端，也可以考虑 volatile完整性限定符，它给出了另外四种组合，将总数增加到八种，仅此而已。但这种情况更为罕见。

关于c++ - 不同引用限定符重载运算符结果的类型特征，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/23404252/