所以基本上我正在编写一个模板来确定表达式的类型(在这种情况下是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上返回一个调用。这是为什么? 有没有办法可以获得我想要的结果?我想要的是正确的吗?
我知道为不同的限定符返回不同类型的运算符不仅非常罕见,而且可能是一种不好的做法,但这并不意味着我不必理解我观察到的行为。
答案 0 :(得分:2)
您需要的是
(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>()
1}}:
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
参数,但我现在没有测试。)
现在,
为不同的限定符返回不同的类型
现在可能很少见,但我发现良好的练习,我认为将来会更频繁。例如,查看std::get
,它可能是非成员函数,但可能同样是成员函数(不是出于技术原因,例如必须编写template
关键字)。 STL容器中的成员begin()
,end()
不是那样(还),我不知道它们是否以及何时会出现,但我相信这将是正确的方法。
我总是忽略const&&
的情况,因为我从未见过有用的用法,我想我记得读过Stroustrup说同样的话。右值引用的想法正是能够修改一个临时对象(这是有道理的,因为这个对象可能包含对实际数据的指针或引用)。所以似乎没有使用const&&
const&
不会完全相同。
另一方面,人们也可以考虑volatile
限定符的完整性,它提供了四种组合,将总数提高到八,这就是全部。但这更为罕见。