一、 d e c l v a l declval declval的基本概念和常规范例
s t d : : d e c l v a l std::declval std::declval 是 C + + 11 C++11 C++11标准中出现的一个函数模板。这个函数模板设计的比较奇怪（没有实现，只有声明），因此无法被调用，通常是和 d e c l t y e decltye decltye和 s i z e o f sizeof sizeof等关键字一起使用，来进行类型推导等等。
下面是 d e c l v a l declval declval的一般源码实现：
//declval的源码形式，只有声明没有实现，一般是配合decltype使用的
template<typename T>
std::add_rvalue_reference_t<T>declval() noexcept;
这里的 s t d : : a d d _ r v a l u e _ r e f e r e n c e _ t std::add\_rvalue\_reference\_t std::add_rvalue_reference_t是 s t d : : a d d _ r v a l u e _ r e f e r e n c e std::add\_rvalue\_reference std::add_rvalue_reference的别名模板，用于将传入的类型加入 & & \&\& &&，下面是它的使用：
//将传入的类型加上两个&&
void Test1() {
using Type1 = std::add_rvalue_reference<int>::type;
std::cout << "Type1 = " << type_id_with_cvr<Type1>().name() << "\n";
using Type2 = std::add_rvalue_reference<int&>::type;
std::cout << "Type2 = " << type_id_with_cvr<Type2>().name() << "\n"; //折叠后还是&
using Type3 = std::add_rvalue_reference<int&&>::type;
std::cout << "Type3 = " << type_id_with_cvr<Type3>().name() << "\n"; //折叠后还是&&
//也可以是用别名模板
using Type4 = std::add_rvalue_reference_t<const int>;
std::cout << "Type4 = " << type_id_with_cvr<Type4>().name() << "\n";
}
一般在传入参数的时候，会发生折叠引用，如 & + & & = & \&+\&\& = \& &+&&=&，这里不多讨论。
下面是运行结果：
至于为什么返回右值引用，而不返回左值引用，下面将会介绍。
二、 s t d : : d e c l v a l std::declval std::declval的使用
2.1 类 A A A的实现
首先，我们存在这么一个类 A A A，用于测试：
//std::declval的简单使用
class A {
public:
A(int i) {
std::cout << "A::A()函数执行了,this = " << this << "\n";
}
double myfunc(double x = 12.1) {
std::cout << "A::myfunc()函数执行了，this = " << this << "\n";
return x;
}
};
2.2 推导 d e c l v a l declval declval返回的类名
然后，我们可以利用 d e c l t y p e + d e c l v a l decltype+declval decltype+declval来推导 A A A的类型名，如下，注意 d e c l v a l declval declval后面需要跟着一个 ( ) () ()表示函数调用：
using YT = decltype(std::declval<A>()); //将A转为右值引用
std::cout << "YT = " << type_id_with_cvr<YT>().pretty_name() << "\n";
返回的类型是 A A A与 & & \&\& &&进行折叠后的结果，是一个右值引用类型。
2.3 推导 d e c l v a l declval declval返回的函数返回值类型
在类 A A A存在成员函数，如果我们想要推导这个成员函数的返回值类型，我们需要怎么做呢？
通常情况下，我们可能这样写代码：
A tmp(1);
std::cout << "mydouble() 返回类型 = " <<
type_id_with_cvr<decltype((tmp.myfunc()))>().pretty_name() << "\n";
然而，这样推导会调用这个函数，如下：
但是，如果我们通过 d e c l v a l declval declval来推导返回值，就不会调用这个函数，这也是 d e c l v a l declval declval的使用场景之一，并且，由于没有实例化出这个类，我们无需提供它的构造函数参数（如果存在），如下：
//如果不想调用函数而推导处函数返回值，因为decltype不会调用函数
std::cout << "mydouble() 返回类型 = " <<
type_id_with_cvr<decltype(std::declval<A>().myfunc())>().pretty_name() << "\n";
可以发现，没有调用函数就推导出了其返回值类型：
这样的写法可以看做 d e c l v a l < A > ( ) declval<A>() declval<A>()返回一个 A & & A\&\& A&&的临时变量，然后这个临时变量调用了 m y f u n c ( ) myfunc() myfunc()函数。
可以参考下面的写法：
如果直接调用
a
y
i
n
o
b
j
k
(
)
ayinobjk()
ayinobjk()，将会链接错误，因为这个函数没有实现。
而如果通过
d
e
c
l
t
y
p
e
decltype
decltype，那么将不会编译失败，也不会链接失败：
下图的写法实际上是推导出了
d
o
u
b
l
e
double
double类型，然后定义了
d
o
u
b
l
e
double
double类型的变量
m
y
d
b
l
v
a
l
mydblval
mydblval。
通过这个例子，也就可以理解了
d
e
c
l
v
a
l
<
A
>
(
)
.
m
y
f
u
n
c
(
)
declval<A>().myfunc()
declval<A>().myfunc()的写法了。
三、 d e c l v a l declval declval返回右值的原因
3.1 返回值自身的问题
首先我们实现三种返回值的 d e c l v a l declval declval：
//返回值
template<typename T>
T mydeclval() noexcept; //只声明，无法被调用
//返回右值引用
template<typename T>
T&& mydeclval2() noexcept; //只声明，无法被调用
//返回左值引用也行
template<typename T>
T& mydeclval3() noexcept; //只声明，无法被调用
我们类 A A A中加入一个 p r i v a t e private private的析构函数：
//std::declval的简单使用
class A {
public:
A(int i) {
std::cout << "A::A()函数执行了,this = " << this << "\n";
}
double myfunc(double x = 12.1) {
std::cout << "A::myfunc()函数执行了，this = " << this << "\n";
return x;
}
private:
~A() {
std::cout << "A::~A()函数执行了\n";
}
};
此时，如果我们使用返回值类型的 d e c l t y p e decltype decltype，语义上将会编译错误：
std::cout << "mydeclval<A>的返回类型 = " << type_id_with_cvr<decltype(mydeclval<A>())>().pretty_name() << "\n";
//无法被析构，从语义上要实例化一个临时对象A（尽管实际上并不会）
std::cout << "mydeclval<A>的返回类型 = " << type_id_with_cvr<decltype(mydeclval<A>().myfunc())>().pretty_name() << "\n";
//同样的还有sizeof，也会编译失败
std::cout << "mydeclval<A>的大小 = " << sizeof(mydeclval<A>()) << "\n";
因为是返回值类型，所以会生成一个临时变量，但是这个临时变量的析构函数在 p r i v a t e private private内，无法被析构，因此编译器会报错（编译器无法生成一个不能析构的变量），即使使用 d e c l t y p e decltype decltype不会实例化出任何类型。
如果这里使用左值引用或右值引用的返回类型，就可以顺利通过编译了，因为是返回引用，所以无需考虑创建副本、析构的问题，因此在语义上是能通过编译的：
std::cout << "mydeclval<A>的返回类型 = " << type_id_with_cvr<decltype(mydeclval<A>())>().pretty_name() << "\n";
//无法被析构，从语义上要实例化一个临时对象A（尽管实际上并不会）
std::cout << "mydeclval<A>的返回类型 = " << type_id_with_cvr<decltype(mydeclval<A>().myfunc())>().pretty_name() << "\n";
//同样的还有sizeof，也会编译失败
std::cout << "mydeclval<A>的大小 = " << sizeof(mydeclval<A>()) << "\n";
3.2 返回左值引用还是右值引用
我们知道，如果形参是 & \& &，那么通过折叠引用返回的类型永远都将是 & \& &，左值引用，无法得到右值引用。
运行下面的代码：
//返回左值引用还是右值引用
void Test4() {
//如果是右值引用
std::cout << "返回值为A&&的折叠引用情况：\n";
std::cout << "decltype<mydecltype2<A>()>返回类型为：" <<
type_id_with_cvr<decltype(mydeclval2<A>())>().pretty_name() << "\n";
std::cout << "decltype<mydecltype2<A&>()>返回类型为：" <<
type_id_with_cvr<decltype(mydeclval2<A&>())>().pretty_name() << "\n";
std::cout << "decltype<mydecltype2<A&&>()>返回类型为：" <<
type_id_with_cvr<decltype(mydeclval2<A&&>())>().pretty_name() << "\n";
std::cout << "\n";
//如果是左值引用
std::cout << "返回值为A&的折叠引用情况：\n";
std::cout << "decltype<mydecltype3<A>()>返回类型为：" <<
type_id_with_cvr<decltype(mydeclval3<A>())>().pretty_name() << "\n";
std::cout << "decltype<mydecltype3<A&>()>返回类型为：" <<
type_id_with_cvr<decltype(mydeclval3<A&>())>().pretty_name() << "\n";
std::cout << "decltype<mydecltype3<A&&>()>返回类型为：" <<
type_id_with_cvr<decltype(mydeclval3<A&&>())>().pretty_name() << "\n";
}
可见，使用右值引用可以得到两种引用情况，而使用左值引用只能得到左值引用类型：
3.2 调用引用限定符修饰的成员函数
通常，成员函数可以用一些限定，写在函数的
(
)
()
()之后，如
c
o
n
s
t
/
&
/
&
&
const/\&/\&\&
const/&/&&等等，而调用它的类型也必须满足这样的限定。
我们这里具体讨论一下，参考下方代码：
//调用引用限定符修饰的成员函数
class ALR {
public:
void onAnyValue() {
std::cout << "ALR::onAnyValue()函数执行了\n";
}
void onLvalue()& { //只能被ALR的左值对象调用
std::cout << "ALR::onLvalue()函数执行了\n";
}
void onRvalue()&& { //只能被ALR的右值对象调用
std::cout << "ALR::onRvalue()函数执行了\n";
}
};
void Test5() {
//返回右值引用
decltype(mydeclval2<ALR>().onAnyValue()); //成功，没有限制
//decltype(mydeclval2<ALR>().onLvalue()); //失败，&& 不能调用 &
decltype(mydeclval2<ALR>().onRvalue()); //成功，&& 调用&&
decltype(mydeclval2<ALR&>().onAnyValue()); //成功，没有限制
decltype(mydeclval2<ALR&>().onLvalue()); //成功，&+ && = &
//decltype(mydeclval2<ALR&>().onRvalue()); //失败，&+&& = &，不能调用&&
decltype(mydeclval2<ALR&&>().onAnyValue()); //成功，没有限制
//decltype(mydeclval2<ALR&&>().onLvalue()); //失败，&&+ && = &&，不能调用&
decltype(mydeclval2<ALR&&>().onRvalue()); //成功，&&+&& = &&
//返回左值引用
decltype(mydeclval3<ALR>().onAnyValue()); //成功，没有限制
decltype(mydeclval3<ALR>().onLvalue()); //成功，&调用&
//decltype(mydeclval3<ALR>().onRvalue()); //失败，& 调用&&
decltype(mydeclval3<ALR&>().onAnyValue()); //成功，没有限制
decltype(mydeclval3<ALR&>().onLvalue()); //成功，&+ & = &
//decltype(mydeclval3<ALR&>().onRvalue()); //失败，&+& = &，不能调用&&
decltype(mydeclval3<ALR&&>().onAnyValue()); //成功，没有限制
decltype(mydeclval3<ALR&&>().onLvalue()); //成功，&&+ & = &，调用&
//decltype(mydeclval3<ALR&&>().onRvalue()); //失败，&+&& = &，不能调用&&
}
通过折叠引用，以上注释起来的部分将会编译失败，因为限定符不符。
通过观察，我们发现如果返回左值引用，那么将无法调用右值引用限定符的成员函数，而如果返回右值引用，则没有这种情况发生。 因此， d e c l v a l declval declval返回右值引用比较合适。
四、推导函数返回值
4.1 全局函数
使用 d e c l v a l declval declval可以用于推导函数返回值，参考下方模板：
//declval推导函数返回值
int myfunc(int a, int b) {
std::cout << "调用了myfunc函数\n";
return a + b;
}
//函数模板用于推导函数返回值
template<typename T_F, typename... U_Args>
decltype(std::declval<T_F>()(std::declval<U_Args>()...)) TestFnRtnImpl(T_F func, U_Args... args) {
std::cout << "---------------begin---------------\n";
std::cout << "T_F:" << type_id_with_cvr<T_F>().pretty_name() << "\n";
std::cout << "---------------end---------------\n";
auto rtnvalue = func(args...);
return rtnvalue;
}
如果调用以下函数：
//declval推导函数返回值
int myfunc(int a, int b) {
std::cout << "调用了myfunc函数\n";
return a + b;
}
auto res = TestFnRtnImpl(myfunc, 1, 2);
其中，上面的 d e c l t y p e ( s t d : : d e c l v a l < T _ F > ( ) ( s t d : : d e c l v a l < U _ A r g s > ( ) . . . ) ) decltype(std::declval<T\_F>()(std::declval<U\_Args>()...)) decltype(std::declval<T_F>()(std::declval<U_Args>()...))可以看做： i n t ( ∗ & & ) ( i n t , i n t ) （ i n t & & , i n t & & ） int(*\&\&)(int,int)（int\&\&,int\&\&） int(∗&&)(int,int)（int&&,int&&）类型。
即传入的函数名是一个函数指针，返回函数指针的右值引用。然后后面的一个 d e c l v a l declval declval用于展开参数包，注意 . . . ... ...的写法。
当然，我们也能使用 a u t o + d e c l t y p e auto+decltype auto+decltype的方式推导返回类型，也是一样的：
// 使用 decltype 和 auto 推导函数的返回类型
template<typename T_F, typename... U_Args>
auto TestFnRtnImpl2(T_F func, U_Args... args) -> decltype(func(args...)) {
std::cout << "---------------begin---------------\n";
std::cout << "T_F:" << type_id_with_cvr<T_F>().pretty_name() << "\n";
std::cout << "---------------end---------------\n";
return func(args...);
}
如下所示：
4.2 成员函数
同样的，也可以使用 d e c l v a l declval declval来推导成员函数返回值，只不过需要实例化出一个成员（不是静态成员函数），利用到的是成员函数指针和这个对象的地址。
参考下方代码：
//函数模板用于推导成员函数返回值
template<typename T_F, typename T_Obj, typename... U_Args>
decltype((std::declval<T_Obj*>()->*std::declval<T_F>())(std::declval<U_Args>()...))
TestFnRtnImp3(T_Obj* obj, T_F func, U_Args... args) {
//绑定发生了偏移
std::cout << "---------------begin---------------\n";
std::cout << "T_F:" << type_id_with_cvr<T_F>().pretty_name() << "\n";
std::cout << "T_Obj:" << type_id_with_cvr<T_Obj>().pretty_name() << "\n";
std::cout << "---------------end---------------\n";
return (obj->*func)(args...);
}
//使用auto+decltype推导成员函数返回值
template<typename T_F, typename T_Obj, typename... U_Args>
auto TestFnRtnImp4(T_Obj* obj, T_F func, U_Args... args) -> decltype((obj->*func)(args...)) {
//绑定发生了偏移
std::cout << "---------------begin---------------\n";
std::cout << "T_F:" << type_id_with_cvr<T_F>().pretty_name() << "\n";
std::cout << "T_Obj:" << type_id_with_cvr<T_Obj>().pretty_name() << "\n";
std::cout << "---------------end---------------\n";
return (obj->*func)(args...);
}
只是，有个细节需要注意的，这里发生了绑定的偏移，原本绑定成员函数指针的变量绑定上了对象地址：
同样的，
(
s
t
d
:
:
d
e
c
l
v
a
l
<
T
_
O
b
j
∗
>
(
)
−
>
∗
s
t
d
:
:
d
e
c
l
v
a
l
<
T
_
F
>
(
)
)
(
s
t
d
:
:
d
e
c
l
v
a
l
<
U
_
A
r
g
s
>
(
)
.
.
.
)
(std::declval<T\_Obj*>()->*std::declval<T\_F>())(std::declval<U\_Args>()...)
(std::declval<T_Obj∗>()−>∗std::declval<T_F>())(std::declval<U_Args>()...)，这里可以看做是：
d
o
u
b
l
e
(
A
∗
)
:
:
(
d
o
u
b
l
e
)
(
d
o
u
b
l
e
&
)
double (A*)::(double)(double\&)
double(A∗)::(double)(double&)，和之前的全局函数类似。
![[深度学习]Pytorch框架](https://i-blog.csdnimg.cn/direct/b54ebf298b2e4b64a19c32192a16b068.png)
