Effective Modern C++[实践]-＞理解decltype

已于 2022-06-28 10:41:09 修改
阅读量511 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 算法
于 2022-06-27 20:52:00 首次发布
本文原创作者：-西门吹雪 MMTS_yang
本文链接：https://blog.csdn.net/MMTS_yang/article/details/125488459
版权

decltype关键字

何谓decltype

decltype 是“declare type”的缩写，译为“声明类型”。
decltype说明符是c++ 11引入的另一个新特性。decltype检查实体的声明类型，或表达式的类型和值类别。
语法如下：

decltype ( 实体 ) 	  (1) 	  (C++11 起)
decltype ( 表达式 ) 	  (2) 	  (C++11 起)

推导规则说明：

规则1

  1. 如果实参是没有括号的标识表达式或没有括号的类成员访问表达式，那么 decltype 产生以该表达式命名的实体的类型。如果没有这种实体或该实参指名了一组重载函数，那么编译错误。
  • 示例1
#include <vector>
int main() {
	int x = 42;
    std::vector<decltype(x)> v(100, x); // v 是一个 vector<int>
}

生成的代码如下

#include <vector>
int main(){
  int x = 42;
  std::vector<decltype(x)> v = std::vector<int, std::allocator<int> >(100, x, std::allocator<int>());
  return 0;
}
  • 示例2
struct S {
    int x = 42;
};
const S s;
decltype(s.x) y; // Y的类型是int，尽管s.x是const

生成的代码如下

 struct S{
  int x;
  // inline constexpr S() noexcept = default;
};
int main(){
  const S s = S();
  int y;
  return 0;
}
  • 示例3
int func(){
    return 0;
}
int func(int a){
    return 0;
}
int main(){
    int i = 4;
    // 不正确的使用。Func为重载函数命名
    decltype(func) var1;
    // 正确的使用。重载操作没有歧义
    decltype(func(i)) var2;
    return 0;
}

规则2

  1. 如果实参是其他类型为 T 的任何表达式，且
    1. 如果 表达式 的值类别是亡值，将会 decltype 产生 T&&；
    2. 如果 表达式 的值类别是左值，将会 decltype 产生 T&；
    3. 如果 表达式 的值类别是纯右值，将会 decltype 产生 T。该类型不需要是完整类型或拥有可用的析构函数，而且类型可以是抽象的。此规则不适用于其子表达式：decltype(f(g())) 中，g() 必须有完整类型，但 f() 不必。

注意：如果对象的名字带有括号，那么它会被当做通常的左值表达式，从而 decltype(x) 和 decltype((x)) 通常是不同的类型。在难以或不可能以标准写法进行声明的类型时，decltype 很有用，例如 lambda 相关类型或依赖于模板形参的类型。
示例1

int f() { return 42; }
int& g() { static int x = 42; return x; }

int main() {
	int x = 42;
	decltype(f()) a = f(); // a的类型是int
	decltype(g()) b = g(); // b的类型是int&
	decltype((x)) c = x;   // c的类型是int&，因为x是左值
}

生成的代码如下：

int f(){ return 42;}
int & g(){
  static int x = 42;
  return x;
}
int main(){
  int x = 42;
  int a = f();
  int & b = g();
  int & c = x;
  return 0;
}

综合示例：

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

struct A { double x; };

int&& f1(void);  //返回值为 int&&

int main() {
    int var = 1;
    
    const A *a = new A();
    decltype(f1()) a1 = 0 ;
	decltype(var) a2 ;
	decltype(a->x) a3;
    decltype((a->x)) a4 =11;
}

编译生成代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

struct A
{
  double x;
};
int && f1();
  //返回值为 int&&

int main()
{
  int var = 1;
  const A * a = new A();
  
  int && a1 = 0;//decltype(f1()) a1 = 0 ;
  int a2;//decltype(var) a2 ;
  double a3;//decltype(a->x) a3;
  const double & a4 = 11;//decltype((a->x)) a4 =11;
  return 0;
}
decltype类型说明
decltype(f1()) a1const int&& 一个指向const int对象的右值引用。
decltype(var);int 变量var的类型。
decltype(a->x); double成员访问的类型。
decltype((a->x)) a4const double&内部圆括号导致语句被作为表达式而不是成员访问进行计算。由于a被声明为const指针，该类型是const double类型的引用。

应用

应用1

c++11中，比较典型的应用示例是decltype与type\using的合用。

using size_t = decltype(sizeof(0));
using ptrdiff_t = decltype((int*)0-(int*)0);
using nullptr_t = decltype(nullptr);

应用2

  1. c++11
template<typename T, typename U>
auto add(T&& t, U&& u) -> decltype(t+u) { return t + u; }

int main() {
	int x = 42;
  	double y = 77.22;
  	add(x,y);
}

生成代码如下：

template<typename T, typename U>
auto add(T&& t, U&& u) -> decltype(t+u) { return t + u; }

/* First instantiated from: insights.cpp:8 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
double add<int &, double &>(int & t, double & u)
{
  return static_cast<double>(t) + u;
}
#endif
int main()
{
  int x = 42;
  double y = 77.219999999999999;
  add(x, y);
  return 0;
}
  1. c++14
template<typename T, typename U>
decltype(auto) add1(T&& t, U&& u){ return t + u; }

int main() {
	int x = 42;
  	double y = 77.22;
  	add1(x,y);
}

生成的代码如下：

template<typename T, typename U>
decltype(auto) add1(T&& t, U&& u){ return t + u; }

#ifdef INSIGHTS_USE_TEMPLATE
template<>
double add1<int &, double &>(int & t, double & u){
  return static_cast<double>(t) + u;
}
#endif
int main(){
  int x = 42;
  double y = 77.219999999999999;
  add1(x, y);
  return 0;
}

书中示例研习

缺陷代码1

template<typename T, typename U>
auto authAndAcess(T &t,U u){
	return t[u];
}

此代码调用authAndAcess(d,5)后推导代码如下：

template<>
int authAndAcess<std::deque<int, std::allocator<int> >, int>(std::deque<int, std::allocator<int> > & t, int u)
{
  return t.operator[](u);
}

原因为：auto关键字进行类别推导时会忽略引用特性，因此虽然d[5]返回的时int &,但是最终却是int的结果。因此无法执行authAndAcess(d,5)=10

缺陷代码2

//推导为int &，但是无法接收右值容器
template<typename T, typename U>
decltype(auto) authAndAcess1(T &t,U u){
	return t[u];
}

此代码调用authAndAcess(d,5)后推导代码如下：

template<>
int & authAndAcess1<std::deque<int, std::allocator<int> >, int>(std::deque<int, std::allocator<int> > & t, int u)
{
  return t.operator[](u);
}

可以实现赋值了，但是形参第一个无法接收右值

c++14的最终版本如下

#include <iostream>
#include <deque>
using namespace std;
//推导为int ，无法对返回值赋值
template<typename T, typename U>
auto authAndAcess(T &t,U u){
	return t[u];
}
//推导为int &，但是无法接收右值容器
template<typename T, typename U>
decltype(auto) authAndAcess1(T &t,U u){
	return t[u];
}
//c++ 14的最终版本
template<typename T, typename U>
decltype(auto) 
authAndAcess2(T &&t,U u){
	return std::forward<T>(t)[u];
}

std::deque<std::string> makeStringDeque(){
	return {"1","2","3","4","5"};
}
int main() {
	std::deque<int> d={0,1,2,3,4,5,6,7};
  
  	authAndAcess(d,5);
  	authAndAcess1(d,5)=10;
    //note: candidate function [with T = std::deque<std::basic_string<char>>, U = int] not viable: expects an lvalue for 1st argument
  	//authAndAcess1(makeStringDeque(),2);//第一个参数是左值，不能传入右值
  	auto s = authAndAcess2(makeStringDeque(),5);
  	authAndAcess2(d,5)= 12;
  	//std::deque<std::string> makeStringDeque();
}

编译后代码生成的代码如下：

#include <iostream>
#include <deque>
using namespace std;
//推导为int ，无法对返回值赋值
template<typename T, typename U>
auto authAndAcess(T &t,U u){
	return t[u];
}

#ifdef INSIGHTS_USE_TEMPLATE
template<>
int authAndAcess<std::deque<int, std::allocator<int> >, int>(std::deque<int, std::allocator<int> > & t, int u)
{
  return t.operator[](u);
}
#endif

//推导为int &，但是无法接收右值容器
template<typename T, typename U>
decltype(auto) authAndAcess1(T &t,U u){
	return t[u];
}

#ifdef INSIGHTS_USE_TEMPLATE
template<>
int & authAndAcess1<std::deque<int, std::allocator<int> >, int>(std::deque<int, std::allocator<int> > & t, int u)
{
  return t.operator[](u);
}
#endif

//c++ 14的最终版本
template<typename T, typename U>
decltype(auto) authAndAcess2(T &&t,U u){
	return std::forward<T>(t)[u];
}

#ifdef INSIGHTS_USE_TEMPLATE
template<>
std::basic_string<char> & authAndAcess2<std::deque<std::basic_string<char>, std::allocator<std::basic_string<char> > >, int>(std::deque<std::basic_string<char>, std::allocator<std::basic_string<char> > > && t, int u)
{
  return std::forward<std::deque<std::basic_string<char>, std::allocator<std::basic_string<char> > > >(t).operator[](static_cast<unsigned long>(u));
}
#endif


#ifdef INSIGHTS_USE_TEMPLATE
template<>
int & authAndAcess2<std::deque<int, std::allocator<int> > &, int>(std::deque<int, std::allocator<int> > & t, int u)
{
  return std::forward<std::deque<int, std::allocator<int> > &>(t).operator[](static_cast<unsigned long>(u));
}
#endif


std::deque<std::basic_string<char>, std::allocator<std::basic_string<char> > > makeStringDeque()
{
  return std::deque<std::basic_string<char>, std::allocator<std::basic_string<char> > >{std::initializer_list<std::basic_string<char> >{std::basic_string<char>(std::basic_string<char>("1", std::allocator<char>())), std::basic_string<char>(std::basic_string<char>("2", std::allocator<char>())), std::basic_string<char>(std::basic_string<char>("3", std::allocator<char>())), std::basic_string<char>(std::basic_string<char>("4", std::allocator<char>())), std::basic_string<char>(std::basic_string<char>("5", std::allocator<char>()))}, std::allocator<std::basic_string<char> >()};
}

int main()
{
  std::deque<int> d = std::deque<int, std::allocator<int> >{std::initializer_list<int>{0, 1, 2, 3, 4, 5, 6, 7}, std::allocator<int>()};
  authAndAcess(d, 5);
  authAndAcess1(d, 5) = 10;
  std::basic_string<char> s = std::basic_string<char>(authAndAcess2(makeStringDeque(), 5));
  authAndAcess2(d, 5) = 12;
  return 0;
}
-西门吹雪
关注
专栏目录
Effective Modern C++ 条款3：理解decltype
cf18862344377的博客
04-29 866
在这个模板中，我们不知道我们操纵的容器的类型是什么，那意味着我们同样不知道它使用的索引对象（index objects）的类型，对一个未知类型的对象使用传值通常会造成不必要的拷贝，对程序的性能有极大的影响，还会造成对象切片行为（参见。举个例子，假定我们写一个函数，一个形参为容器，一个形参为索引值，这个函数支持使用方括号的方式（也就是使用“这样的代码将会把你送上未定义行为的特快列车，一辆你绝对不想上第二次的车。“符号指出函数的返回类型，尾置返回类型的好处是我们可以在函数返回类型中使用函数形参相关的信息。
Effective Modern C++ 条款3 理解decltype
大黄鸭
08-09 1864
Effective Modern C++ 条款3
理解 decltype关键字
ZZHinclude的博客
01-12 301
1. decltype关键字 decltype被称作类型说明符，它的作用是选择并返回操作数的数据类型。 例如 Test2函数的返回值是std::initializer_list类型 std::initializer_list<int> Test2() { return { 1,2,3 }; } 我们使用一致化初始列表 decltype(Test2()) Arr1 = { 1,2,3 }; 可以运行，所以decltype关键字得到了Test2返回值的类型 2.更多的常规例子 cons
C++11 类型推导decltype（一）
斧冰
08-21 715
我们之前使用的typeid运算符来查询一个变量的类型，这种类型查询在运行时进行。RTTI机制为每一个类型产生一个type_info类型的数据，而typeid查询返回的变量相应type_info数据，通过name成员函数返回类型的名称。同时在C++11中typeid还提供了hash_code这个成员函数，用于返回类型的唯一哈希值。RTTI会导致运行时效率降低，且在泛型编程中，我们更需要的是编译时就要确定类型，RTTI并无法满足这样的要求。编译时类型推导的出现正是为了泛型编程，在非泛型编程中，我们的类型都是确定
最全面&&最清晰易懂的map/set/auto/decltype/pair/vector/string常见用法说明大全
lxt_Lucia的博客
07-27 828
欢迎访问https://blog.csdn.net/lxt_Lucia～～ 宇宙第一小仙女\(^o^)/～～萌量爆表求带飞=≡Σ((( つ^o^)つ~ dalao们点个关注呗～～   摘要          最近学了map，set，auto，decltype，pair，vector等，有点琐碎， 现在放在一起来总结一下，方便理解和以后查找，也方便大家查阅 ～   Come on！...
candidate function not viable: expects an l-value for 1st argument
技术的学习与积累是个技术活
04-22 5526
说明 编译出错的信息是说方法的参数期望的是一个左值！一般像我这类不熟悉C++的又用经常切换多种编程语言的人是有可能遇到这个类基础的问题。还有我发现在复杂的函数定义然后在Android studio的开发环境下，出错的提示会有些不一样，但基本上会看出是左右值的问题 这里的case就是扯到C++的引用参数和C++的左值与右值的知识点了，在网络搜索了下相关的学习资料并整理在文章最后，同大家一起分享与共同学习之 示例代码 C++的代码（IDE是CLion） #include <iostream> #
Effective Modern C++ 纯人工翻译，持续更新，不为博你眼球，旨在自我提升
07-12 1755
纯手动翻译Effective Modern C++，志在学习，不为博你眼球！
Effective Modern C++实践指南：提升C++11与C++14使用技巧
"Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14 by Scott Meyers" 《Effective Modern C++》是著名C++专家斯科特·梅耶斯（Scott Meyers）撰写的一本指南，旨在帮助开发者充分...
Effective Modern C++实践指南
"Effective Modern C++ 是一本专注于C++11及后续版本最佳实践的书籍，旨在帮助开发者充分利用现代C++的特性，提升代码质量和效率。书中涵盖了模板类型推导、auto关键字、decltype、查看推导类型、auto与显式类型声明...
[读书笔记]《Effective Modern C++》—— 类型推导、auto、decltype
Chris_zhangrx的博客
02-07 809
文章目录前言条款一： 理解模板型别推导数组实参函数实参条款二：理解 auto 的类型推导使用 auto 的好处显式类型初始化条款三：理解 decltype返回值类型后置总结 前言 本文内容主要摘录自 《Effective Modern C++》，本文主要是将书中开头类型推导部分的内容放在一块进行说明，在再次品读这部分内容之前，对模板的认识就仅仅停留在模板是长这个样子的，使用的时候可以特化或者偏特化，对更深入的内容不曾有意识涉及。通过下面的内容对 C++ 的类型推导，以及 auto 和 decltype 等关
c++11中decltype的妙用
.
11-29 5011
下面是《深入理解c++11》中的部分截图 以下是自己的实现，实用几个宏，实现对多用类成员变量的setter和getter #define GetProperty(Var,VarName) inline auto Get##VarName() const ->decltype(Var) { return Var;} #define SetProperty(Var,Va
C/C++编程：decltype
OceanStar的博客
03-22 755
多维数组指针 多维数组是一种常见的数据结构，实际上是数组的数组。这个含义虽然很好理解，但是在定义操作数组数据的指针时却有点麻烦。假设有下面的二维数组。 int matrix[10][10]; 定义指向其中一行的指针时，下面那种方式是对的呢？ int *row[10]; int (*row)[10]; 答案是第二种。这里硬记当然是一种办法，但是也可以用换一个方式看代码： int* row[10]; int (*row)[10]; 第一种情况是指针的数组，剩下的就是数组的指针
decltype的使用
Icarus_的学习笔记
01-25 1857
在C++中，decltype作为操作符，用于查询表达式的数据类型。decltype在C++11标准制定时引入，主要是为泛型编程而设计，以解决泛型编程中，由于有些类型由模板参数决定，而难以（甚至不可能）表示之的问题。 泛型编程在整个1990年代越发流行，对实现类型推导机制的需求也应运而生。为此，许多编译器厂商都基于程序语言现有的功能，自行实现了这类操作符，其实现如typeof，以及一些功能有限，但
C++11 类型推导decltype（三）
斧冰
08-21 448
decltype用于生成变量名或者表达式的类型，其生成的结果有的是显而易见的，可以预测的，容易理解，有些则不容易理解。大多数情况下，与使用模板和auto时进行的类型推断相比，decltype作用于变量名或者表达式只是重复了一次变量名或者表达式的确切类型： const int i = 0; // decltype(i) 为 const int bool f(const Widget& w); // decltype(w)
C++17完整导引-模板特性之折叠表达式
最新发布
西门吹雪
05-22 896
模板特性之折叠表达式
C++11新特性之auto&decltype
hailong0715的专栏
12-29 4239
C++11中引入了auto&decltype关键字实现类型推导，通过这两个字可以方便的获取复杂的类型还可以简化代码，提高编码效率。 auto关键字 auto类型推导 C++98/03中一直就有auto关键字了，只不过在C++98/03中auto关键字用于标识具有自动存储期的局部变量，它的作用并不大，在实际的编码过程中我们基本没有用过auto关键字，比如 auto int i = 0;  /
C++11之decltype
weixin_30685029的博客
04-20 139
使用场景 在C++中经常要用到很长的变量名，如果已经有变量和你将使用的变量是一个类型，即可使用decltype关键字 来申明一样的类型变量。 decltype原理 返回现有变量类型，decltype是一个关键字，而不是一个函数，这有啥区别呢？decltype在编译阶段返回变量类 型，而不是在运行阶段传递不同变量返回不同值。 decltype使用范例 ...
C++ decltype用法详解
热门推荐
天启的博客
07-08 2万+
1.什么是decltype decltype是C++11新增的一个关键字，和auto的功能一样，用来在编译时期进行自动类型推导。引入decltype是因为auto并不适用于所有的自动类型推导场景，在某些特殊情况下auto用起来很不方便，甚至压根无法使用。 auto varName=value; decltype(exp) varName=value; auto根据=右边的初始值推导出变量的类型，decltype根据exp表达式推导出变量的类型，跟=右边的value没有关系...
C++ decltype类型推导完全攻略
digitalkee的博客
02-05 708
decltype 是C++11 新增的一个关键字，它和 auto 的功能一样，都用来在编译时期进行自动类型推导。不了解 auto 用法的读者请转到《C++ auto》。 decltype 是“declare type”的缩写，译为“声明类型”。 既然已经有了 auto 关键字，为什么还需要 decltype 关键字呢？因为 auto 并不适用于所有的自动类型推导场景，在某些特殊情况下 auto 用起来非常不方便，甚至压根无法使用，所以 decltype 关键字也被引入到 C++11 中。 auto 和.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-西门吹雪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值