【标准库的典型内容】std::declval

一、$declval$的基本概念和常规范例

$std::declval$ 是$C++11$标准中出现的一个函数模板。这个函数模板设计的比较奇怪（没有实现，只有声明），因此无法被调用，通常是和$decltye$和$sizeof$等关键字一起使用，来进行类型推导等等。

下面是$declval$的一般源码实现：

//declval的源码形式，只有声明没有实现，一般是配合decltype使用的
template<typename T>
std::add_rvalue_reference_t<T>declval() noexcept;

这里的$std::add\_rvalue\_reference\_t$是$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";}

一般在传入参数的时候，会发生折叠引用，如$\&+\&\&=\&$，这里不多讨论。

下面是运行结果：

至于为什么返回右值引用，而不返回左值引用，下面将会介绍。

二、$std::declval$的使用

2.1 类$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 推导$declval$返回的类名

然后，我们可以利用$decltype+declval$来推导$A$的类型名，如下，注意$declval$后面需要跟着一个$()$表示函数调用：

using YT = decltype(std::declval<A>()); //将A转为右值引用std::cout << "YT = " << type_id_with_cvr<YT>().pretty_name() << "\n";

返回的类型是$A$与$\&\&$进行折叠后的结果，是一个右值引用类型。

2.3 推导$declval$返回的函数返回值类型

在类$A$存在成员函数，如果我们想要推导这个成员函数的返回值类型，我们需要怎么做呢？

通常情况下，我们可能这样写代码：

A tmp(1);
std::cout << "mydouble() 返回类型 = " <<type_id_with_cvr<decltype((tmp.myfunc()))>().pretty_name() << "\n";

然而，这样推导会调用这个函数，如下：

但是，如果我们通过$declval$来推导返回值，就不会调用这个函数，这也是$declval$的使用场景之一，并且，由于没有实例化出这个类，我们无需提供它的构造函数参数（如果存在），如下：

//如果不想调用函数而推导处函数返回值，因为decltype不会调用函数
std::cout << "mydouble() 返回类型 = " <<type_id_with_cvr<decltype(std::declval<A>().myfunc())>().pretty_name() << "\n";

可以发现，没有调用函数就推导出了其返回值类型：

这样的写法可以看做$declval<A>()$返回一个$A\&\&$的临时变量，然后这个临时变量调用了$myfunc()$函数。

可以参考下面的写法：

如果直接调用$ayinobjk()$，将会链接错误，因为这个函数没有实现。
而如果通过$decltype$，那么将不会编译失败，也不会链接失败：

下图的写法实际上是推导出了$double$类型，然后定义了$double$类型的变量$mydblval$。

通过这个例子，也就可以理解了$declval<A>().myfunc()$的写法了。

三、$declval$返回右值的原因

3.1 返回值自身的问题

首先我们实现三种返回值的$declval$：

//返回值
template<typename T>
T mydeclval() noexcept; //只声明，无法被调用//返回右值引用
template<typename T>
T&& mydeclval2() noexcept; //只声明，无法被调用//返回左值引用也行
template<typename T>
T& mydeclval3() noexcept; //只声明，无法被调用

我们类$A$中加入一个$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";}
};

此时，如果我们使用返回值类型的$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";

因为是返回值类型，所以会生成一个临时变量，但是这个临时变量的析构函数在$private$内，无法被析构，因此编译器会报错（编译器无法生成一个不能析构的变量），即使使用$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 调用引用限定符修饰的成员函数

通常，成员函数可以用一些限定，写在函数的$()$之后，如$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()); //失败，&+&& = &，不能调用&&}

通过折叠引用，以上注释起来的部分将会编译失败，因为限定符不符。

通过观察，我们发现如果返回左值引用，那么将无法调用右值引用限定符的成员函数，而如果返回右值引用，则没有这种情况发生。 因此，$declval$返回右值引用比较合适。

四、推导函数返回值

4.1 全局函数

使用$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);

其中，上面的$decltype(std::declval<T\_F>()(std::declval<U\_Args>()...))$可以看做：$int(\ast \&\&)(int,int)（int\&\&,int\&\&）$类型。

即传入的函数名是一个函数指针，返回函数指针的右值引用。然后后面的一个$declval$用于展开参数包，注意$...$的写法。

当然，我们也能使用$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 成员函数

同样的，也可以使用$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...);
}

只是，有个细节需要注意的，这里发生了绑定的偏移，原本绑定成员函数指针的变量绑定上了对象地址：
同样的，$(std::declval<T\_Obj\ast >()->\ast std::declval<T\_F>())(std::declval<U\_Args>()...)$，这里可以看做是：$double(A\ast )::(double)(double\&)$，和之前的全局函数类似。