C++ auto和decltype浅析

最近在准备将C++primer练习题上面的代码撸一遍,然而还要面临马上开题的压力,5555.
这里写图片描述
一. auto简介
编程时候常常需要把表达式的值付给变量,需要在声明变量的时候清楚的知道变量是什么类型。然而做到这一点并非那么容易(特别是模板中),有时候根本做不到。为了解决这个问题,C++11新标准就引入了auto类型说明符,用它就能让编译器替我们去分析表达式所属的类型。和原来那些只对应某种特定的类型说明符(例如 int)不同。auto 让编译器通过初始值来进行类型推演。从而获得定义变量的类型,所以说 auto 定义的变量必须有初始值

我们先看一个代码:

#include <iostream>

int main()
{
    int i = 0,&r =i;
    auto a = r ;  //a 是一个整数(r是i的别名,而i是个整数)
    const int ci = i, &cr = ci;
    auto b = ci;  //b是一个整数(ci的顶层const特性被忽视掉了)
    auto c = cr;  //c是一个整数(cr是ci的别名,ci本身是一个顶层const)
    auto d = &i;  //d是一个整型指针(整数的地址就是指向整数的指针)
    auto e = &ci; //e是一个指向整数常量的指针(对常量对象取地址是一种底层const)
    auto &g = ci; //g是一个整型常量引用,绑定到ci
    std::cout << a << " "<< b << " "<< c << " "<< d << " "<< e << " "
    << g << std::endl;

    a = 42;
    b = 42;
    c = 42;
    d = 42;    //错误: d是一个指针,赋值非法
    e = 42;    //错误: e是一个指针,赋值非法
    g = 42;    //错误: g是一个常量引用,赋值非法
    std::cout<< a << " "<< b << " "<< c << " " << d << " "
    << e << " " << g << std::endl;

    return 0;
}

输出结果如下:
这里写图片描述


下面来自:http://blog.csdn.net/y1196645376/article/details/51441503

//由val_1 和val_2相加的结果可以推断出item的类型  
auto item = val_1 + val_2;//item 类型初始化为val_1 + val_2相加后的类型,值为val_1+val_2相加的值。  

这里的 item 的类型是编译器在编译的过程中通过val_1和val_2的类型相加后推算出来的。假如是val_1(int) + val_2(double),那么item的类型就是double.
使用auto也能在一个语句中声明多个变量,因为一个声明语句只能有一个基本数据类型,所以该语句所有变量的初始基本数据类型都必须是一样的。在这里一定要区别数据类型和类型修饰符!!

int i = 3;  
auto a = i,&b = i,*c = &i;//正确: a初始化为i的副本,b初始化为i的引用,c为i的指针.  
auto sz = 0, pi = 3.14;//错误,两个变量的类型不一样。  

编译器推断出来的auto类型有时候会跟初始值的类型并不完全一样,编译器会适当的改变结果类型使得其更符合初始化规则。
首先,正如我们熟知的,使用引用其实是使用引用的对象,特别当引用被用作初始值的时候,真正参与初始化的其实是引用对象的值。此时编译器以引用对象的类型作为auto的类型:

int i = 0 ,&r = i;//定义一个整数i,并且定义r为i的应用.  
auto a = r; //这里的a为为一个整数,其值跟此时的i一样.         

由此可以看出auto会忽略引用,其次,auto一般会忽略掉顶层const,但底层const会被保留下来,比如当初始值是一个指向常量的指针时:

int i = 0;  
const int ci = i, &cr = ci;  //ci 为整数常量,cr 为整数常量引用   
auto a = ci;     // a 为一个整数, 顶层const被忽略  
auto b = cr;     // b 为一个整数,顶层const被忽略  
auto c = &ci;    // c 为一个整数指针.  
auto d = &cr;    // d 为一个指向整数常量的指针(对常量对象区地址是那么const会变成底层const)  

如果你希望推断出auto类型是一个顶层的const,需要明确指出:

const auto f = ci;  

还可以将引用的类型设为auto,此时原来的初始化规则仍然适用(用于引用声明的const都是底层const):

auto &g = ci; //g是一个整数常量引用,绑定到ci。  
auto &h = 42; // 错误:非常量引用的初始值必须为左值。  
const auto &j = 42; //正确:常量引用可以绑定到字面值。   

看一个例子:

#include <iostream>
#include <typeinfo>

int main()
{
    const int i = 42;
    auto j = i;
    const auto &k = i;
    auto *p = &i;
    const auto j2 = i, &k2 = i;
    /*推断结果如下
    由题意可知,i是一个整型常量,j的类型推断结果是整数,k的类型推断结果
    是整型常量,P的类型推断结果是指向整型常量的指针,j2的类型推断结果是整数,
    k2的类型推断结果是整数。
    */
    std::cout<<typeid(i).name()<<std::endl;
    std::cout<<typeid(j).name()<<std::endl;
    std::cout<<typeid(k).name()<<std::endl;
    std::cout<<typeid(p).name()<<std::endl;
    std::cout<<typeid(j2).name()<<std::endl;
    std::cout<<typeid(k2).name()<<std::endl;

    return 0;
}

输出结果如下:
这里写图片描述


二. decltype简介

有的时候我们还会遇到这种情况,我们希望从表达式中推断出要定义变量的类型,但却不想用表达式的值去初始化变量。还有可能是函数的返回类型为某表达式的的值类型。在这些时候auto显得就无力了,所以C++11又引入了第二种类型说明符decltype,它的作用是选择并返回操作数的数据类型。在此过程中,编译器只是分析表达式并得到它的类型,却不进行实际的计算表达式的值。

decltype(f()) sum = x;// sum的类型就是函数f的返回值类型。  

在这里编译器并不实际调用f函数,而是分析f函数的返回值作为sum的定义类型。
基本上decltype的作用和auto很相似,就不一一列举了。对于decltype还有一个用途就是在c++11引入的后置返回类型。

看一道题目:

int a = 3, b = 4;
decltype(a) c = a; //等同于 int c = a,此时c是一个新整型变量
decltype((b)) d = a; //等同于  int &d = a,此时d是变量a的别名
++c;
++d;

对于decltype所用的表达式来说,如果变量名加上一对括号,得到的类型与不加括号会有不同。具体来说,如果decltype使用的是一个不加括号的变量,则得到的结果就是该变量的类型;
如果给变量加上了一层或多层括号,编译器就会把它当做是一个表达式,从而推断得到引用类型。

最后得到输出如下:
这里写图片描述


三. decltype 和 auto 区别

ecltype在处理顶层const和引用的方式与auto有些许不同,如果decltype使用的表达式是一个变量,则decltype返回该变量的类型(包括顶层const和引用在内)。

const int ci = 42, &cj = ci;  

decltype(ci) x = 0;   // x 类型为const int  
auto z = ci;          // z 类型为int  

decltype(cj) y = x;   // y 类型为const int&  
auto h = cj;          // h 类型为int  

decltype还有一些值得注意的地方,我们先来看看下面这段代码:

int i = 42, *p = &i, &r = i;  

decltype(i) x1 = 0;       //因为 i 为 int ,所以 x1 为int  
auto x2 = i;              //因为 i 为 int ,所以 x2 为int  

decltype(r) y1 = i;       //因为 r 为 int& ,所以 y1 为int&  
auto y2 = r;              //因为 r 为 int& ,但auto会忽略引用,所以 y2 为int  

decltype(r + 0) z1 = 0;   //因为 r + 0int ,所以 z1 为int,  
auto z2 = r + 0;          //因为 r + 0int ,所以 z2 为int,  

decltype(*p) h1 = i;      //这里 h1 是int&, 原因后面讲  
auto h2 = *p;             // h2 为 int.  

如果表达式的内容是解引用操作,则decltype将得到引用类型。正如我们所熟悉的那样,解引用指针可以得到指针所指对象,而且还可以给这个对象赋值。因此decltype(*p)的结果类型就是int&.
decltype和auto还有一处重要的区别是,decltype的结果类型与表达形式密切相关。有一种情况需要特别注意:对于decltype 所用表达式来说,如果变量名加上一对括号,则得到的类型与不加上括号的时候可能不同。如果decltype使用的是一个不加括号的变量,那么得到的结果就是这个变量的类型。但是如果给这个变量加上一个或多层括号,那么编译器会把这个变量当作一个表达式看待,变量是一个可以作为左值的特殊表达式,所以这样的decltype就会返回引用类型:

int i = 42;  

//decltype(i)   int  类型  
//decltype((i)) int& 类型  

这里再指出一个需要注意的地方就是 = 赋值运算符返回的是左值的引用。换句话意思就是说 decltype(i = b) 返回类型为 i 类型的引用。仔细看下面这段代码:

int main()  
{  
    int i = 42;  

    decltype(i = 41) x = i;  

    auto y = i;  

    auto& z = i;  

    printf("i x y z 此时为: %d %d %d %d\n", i,x,y,z);  

    i--;  

    printf("i x y z 此时为: %d %d %d %d\n", i, x, y, z);  

    x--;  

    printf("i x y z 此时为: %d %d %d %d\n", i, x, y, z);  

    y--;  

    printf("i x y z 此时为: %d %d %d %d\n", i, x, y, z);  

    z--;  

    printf("i x y z 此时为: %d %d %d %d\n", i, x, y, z);  

    return 0;  
}  

输出如下:
这里写图片描述

总结主要区别如下:
auto和decltype的区别主要有三个方面:
第一,auto类型说明符用编译器计算变量的初始值来推断其类型,而decltype虽然
也让编译器分析表达式并得到它的类型,但是不实际计算表达式的值。
第二,编译器推断出来的auto类型有时候和初始值的类型并不完全一致,编译器会
适当的改变结果类型使其更符合初始化规则,例如,auto一般会忽略掉顶层const,而把
底层const保留下来,与之相反,decltype会保留变量的顶层const。
第三,decltype和auto还有一处重要的区别是,decltype的结果类型与表达形式密切相关。有一种情况需要特别注意:对于decltype 所用表达式来说,如果变量名加上一对括号,则得到的类型与不加上括号的时候可能不同。如果decltype使用的是一个不加括号的变量,那么得到的结果就是这个变量的类型。但是如果给这个变量加上一个或多层括号,那么编译器会把这个变量当作一个表达式看待,变量是一个可以作为左值的特殊表达式,所以这样的decltype就会返回引用类型。

#include <iostream>
#include <typeinfo>

int main()
{
    int a = 3;
    auto c1 = a;
    decltype(a) c2 = a;
    decltype((a)) c3 = a;

    const int d = 5;
    auto f1 = d;
    decltype(d) f2 = d;

    std::cout<<typeid(c1).name()<<std::endl;
    std::cout<<typeid(c2).name()<<std::endl;
    std::cout<<typeid(c3).name()<<std::endl;
    std::cout<<typeid(f1).name()<<std::endl;
    std::cout<<typeid(f2).name()<<std::endl;

    c1++;
    c2++;
    c3++;
    f1++;
    //f2++;         //错误:f2是整型常量,不能执行自增操作
    std::cout<<a << " "<< c1 << " "<< c2 << " "<< c3 <<" "<<
        f1<<" "<< f2 <<std::endl;
    return 0;

}

这里写图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值