C++11---新特性1---nullptr---列表初始化---constexpr---using---auto---decltype

1. nullptr

作用：表示空指针，用于指针初始化。
引入nullptr原因：
由于之前表示空指针，使用宏NULL或0来表示。但是再c和c++中定义如下：

#ifndef NULL
    #ifdef __cplusplus
        #define NULL    0    
    #else  /* __cplusplus */
        #define NULL    ((void *)0)
    #endif  /* __cplusplus */
#endif  /* NULL */
--------------------- 
作者：Fred^_^ 
来源：CSDN 
原文：https://blog.csdn.net/Xiejingfa/article/details/50478512 
版权声明：本文为博主原创文章，转载请附上博文链接！

也就是说在C++中，NULL实际上就是0，在C中是(void*) 0。因为C++是强类型的，无法类型自动转换。
NULL缺点：在函数重载中，若参数为整数和指针时，容易出错，如下：

void Func(char *);
void Func(int);

int main()
{
    Func(NULL);  // 调用Func(int)
}

使用方法： 不能赋给整型。

char *pc = nullptr;     // OK
int  *pi = nullptr;     // OK
bool   b = nullptr;     // OK. b is false.
int    i = nullptr;     // error

2. 列表初始化

C++11支持列表初始化：

int a = { 20 };
int b{ 10 };
int c[] = { 1,2,3 };
b = { 20 };

与常规初始化不同：
当用于内置类型的变量时，若存在丢失数据的风险，则编译器回报错。

int a = { 20 };
double f = 10.1;
a = { f }; //出错，转换无效

3. 常量表达式和constexpr

常量表达式：指值不会发生改变并且在编译阶段就可得到结果的表达式。
作用：使用constexpr表示一个常量表达式
引入原因：以前使用const来表示常量表达式，由两个方面确定表达式到底是否是常量表达式，数据类型（是否有const）和初始值（初始值是否是常量）。

const int a=20; //是常量表达式
const int b=a+1;  //是常量表达式
const int c=size();  //不是常量表达式，因为size()函数不是常量

由于很难分辨初始值到底是不是常量表达式，所以引用constexpr。
使用方法：

constexpr int a=20; //是常量表达式
constexpr int b=a+1;  //是常量表达式
constexpr int c=size();  //因为size()函数不是常量,所以报错

当初始化值不是一个常量时，使用constexpr会报错，这样就可以判断是是常量表达式。

4. using 别名声明

作用：声明类型的别名
引入原因：以前使用typedef来定义类型别名，

typedef int INT;//INT作为int的别名
INT a=10;//等价于int a=10;

但是typedef 无法很好的用于模板中，因此引入using。
使用方法：

using INT=int;//INT作为int的别名
INT a=10;//等价于int a=10;

用于模板中时：

template<typename T1, typename T2> using Map = std::map<T1, std::vector<T2>>;

// Actual type: std::map<std::string, std::vector<std::string>> (as in the original example)
Map<std::string, std::string> map1;

// Actual type: std::map<int, std::vector<int>>
Map<int, int> map2;

5. auto 自动推导类型

作用：auto让编译器通过初始值来推算变量的类型，所以auto定义的变量必须有初始值。
使用方法：

auto i=0, *p=&i;  //i为整型，p为整型指针
auto a=10, pi=2.14;// 运行错误，a为整型，pi为float型。

注意：在一条语句中，声明多个变量，所有变量的初始基本数据类型必须一样。

auto一般会忽略顶层const，底层const会保存下来。

const int ci=10,&c=ci; c是ci的别名。
auto a=ci;  //a是整数，忽略顶层const
auto b=c; //c是ci的别名，ci本身是顶层const
auto d=&ci;  //d是指向整型常量的指针，对常量对象的取地址是一种底层const

可以显式将顶层const推断。

const int ci=10,&c=ci; c是ci的别名。
const auto a=ci;  //a的类型为const int 。

6. decltype 类型指示符

作用：返回操作数的数据类型，编译器分析表达式并得到其返回的数据类型，但不实际计算或调用表达式。

decltype(f()) s=x;  //编译器并不调用f函数，而是将f的返回值类型作为s的类型。

1. decltype处理顶层const和引用的方式于auto不同，若使用的表达式是变量，则返回变量的类型（包括顶层const和引用）。

const int ci=10,&c=ci; c是ci的别名。
decltype(ci) a=0;  //a是const int，不忽略顶层const
decltype(c) b=a; //c是ci的引用，b的类型为const int &
decltype(c) d;  //错误，因为引用必须初始化。

2. 解引用

int x=10,*p=&x;
int x = 10, *p = &x;
decltype(*p) c = x; //解引用指针可以得到指针的对象，所以结果为int &，而不是int。
c = 20;
cout << x << endl;  //此时x=20，所以c是x的引用。

3. 括号 ，加上括号则一定是引用

int x = 10, *p = &x;
decltype(x) c = 20;  //c为int型
decltype((x)) s = x;  //s为x的引用
s = 100;
cout << x << endl << c << endl << s << endl;

则运行结果为：

100
20
100