C++11的std::declval与decltype

1、 decltype关键字

decltype被称作类型说明符，它的作用是选择并返回操作数的数据类型。

decltyoe有：①当使用decltype(var)

const int ci = 0, &cj = ci;

decltype(ci) x = 0; // x的类型是const int

②当使用decltype(expr)

int i = 42, *p = &i, &r = i; // r + 0是一个表达式 // 算术表达式返回右值 // b是一个int类型 decltype(r + 0) b; // b是一个int类型

③当使用decltype(func_name) 更多的decltype的介绍和代码用法见 【C++深陷】之“decltype”_不能自拔-CSDN博客_decltype int add_to(int &des, int ori); FuncType *pf = add_to; pf(a, 2);// 通过函数指针调用add_to

2、decltype和declval的代码用法如下


void_t 判断 类型是否存在class T
{public:int test(){int a = 1;}
}
std::declval:将任何一个类型T转换成引用类型， 在不创建对象的情况下能达到创建对像的效果，
可以使 decltype 表达式中不必经过构造函数就能使用成员函数
eg: decltype(std::declval<T>.test())   //int 这里没有创建T的对象， 也没有执行a = 1;给定一个变量或表达式，decltype能够推导出他的类型。最重要的是能够不需要计算表达式就可以推导出表达式所得值的类型。
struct Default { int foo() const { return 1; } };
struct NonDefault
{NonDefault(const NonDefault&) { }int foo() const { return 1; }
}
decltype(Default().foo()) n1 = 1;                   // type of n1 is int//判断是否有这种类型
#define _HAS_TYPE_MEM_(parMTpNm)\
template<typename T, typename U = std::void_t<>>\
struct HTM_##parMTpNm: std::false_type{}; \
template<typename T>\
struct HTM_##parMTpNm<T, std::void_t<typename T::parMTpNm>>:std::true_type{};eg: std::cout<< _HAS_TYPE_MEM_<classname>::value << std::endl;
//or std::cout<< HTM_type<classname>::value << std::endl;//判断类是否有这种变量
#define _HAS_TYPE_VAR_(parMTpNm)\
template<typename T, typename U = std::void_t<>>\
struct HTM_##parMTpNm: std::false_type{}; \
template<typename T>\
struct HTM_##parMTpNm<T, std::void_t<decltype(T::var)>>:std::true_type{};//判断类中是否存在成员函数
#define _HAS_TYPE_FUN_(parMTpNm)\
template<typename T, typename U = std::void_t<>>\
struct HTM_##parMTpNm: std::false_type{}; \
template<typename T>\
struct HTM_##parMTpNm<T, std::void_t<decltype<T>().parMTpNm>>:std::true_type{};//
typename = int typename = char 等
优先于
typename = void
////// is_copy_assignable() 类对象是否可以拷贝复值
template<typename T, typename U = std::void_t<>>
struct ISCopyAssignable:std::false_type
{
};
template <typename T>
struct ISCopyAssignable<T, std::void_t<decltype(std::declval<T&>()/*临时变量*/ = std::declval<const T&>())> >:std::true_type
{
};std::declval<T&>()/*临时变量*/ = std::declval<const T&>()  它类似 T& operator= (const T &)， 与前面一一对应，  结果为T&
//eg:
template<typename T, typename U, typename V = std::void_t<>>
struct IfCanAdd: std::false_type
{}template<typename T, typename U>
struct IfCanAdd<T, U, std::void_t<decltype(std::declval<T>() + std::declval<U>())>>:std::true_type
{}
/*template<typename T, typename U>struct VerAddRet{//    using type = decltype(T() + U())using type = decltype(std::declval<T>() + std::declval<U>());}
*/
template<typename T, typename U, bool = IfCanAdd<T, U>::value>//泛
struct VerAddRet
{using type = decltype(std::declval<T>() + std::declval<U>());
}template<typename T, typename U>//特
struct VerAddRet<T, U, false>
{}template<typename T, typename U>
std::vector<typename VerAddRet<T, U>::type> operator+(std::verctor<T> const&, std::verctor<T> const&)
{std::verctor<typename VerAddRet<T, U>::type> tmpvec;return tmpvec;
}struct elemC
{elemC(int i);elemC operator+(const elemC&t);
}
std::vector<elemC> vea;
std::vector<elemC> veb;
vea + veb;

上述部分内容转载于C++泛型编程学习 std::declval void_t_网瘾少年丶的博客-CSDN博客_declval 转载请附上原文出处链接和本声明。

详细介绍可以参考下面的文章

【C++深陷】之“decltype”_不能自拔-CSDN博客_decltypehttps://blog.csdn.net/u014609638/article/details/106987131

C++14尝鲜：decltype 和 decltype(auto)_zwvista的专栏-CSDN博客_decltypehttps://blog.csdn.net/zwvista/article/details/54571821

在C++11标准的语法中，auto被定义为自动推断变量的类型。

3、decltype和auto的区别如下：

#include <iostream>
#include <stdlib.h>
using namespace std;
int main()
{const int nCouta = 20;decltype(nCouta) nCountb = 30;auto nCountc = nCountb;cout << "nCounta " << nCouta << endl;cout << "nCountb " << nCountb << endl;//nCountb = 40; //保留的const特性nCountc = 40;   //不会保留const特性const int ci = 50;auto &ra = ci;//ra = 30;      //保留的const int &特性return 0;
}

如果要一次定义两个整型指针，int* a, b;这么做肯定是错的；若使用typedef就可以，

eg: typedef int* intPtr; intPtr a, b;//a b都是指针变量