C++11 新特性整理 (1)

C++11对模板细节的改进：
1. C++11改善了编译器的解析规则，尽可能地将多个右尖括号(>）解析为模板参数结束符，例如在C++98中：

Foo<A<int> > xx;   // 两个右尖括号必须有空格，否则会被编译器解析成右移操作符
return 0;

在C++11中则完全取消了这种限制。

2. 模板的别名：
typedef可以重定义类型，例如：

typedef unsigned int uint;

但是无法重定义模板，在C++11中出现了重定义一个模板的语法：

using 的别名语法涵盖了typedef的全部功能：

template<typename Val>
using map_str_int = std::map<std::string, Val>;

map_str_int<int> map1;

而在C++98中，定义模板的别名只能通过一个外敷类来实现：

template<typename Val>
struct map_str_int    // 外敷类
{
    typedef std::map<std::string, Val> type;
};

map_str_int<int>::type map1;

列表初始化：

C++11中引入了列表初始化的概念，C++98中，只有数组和结构体可以进行列表初始化：

// 数组
int array[] = { 1,2,3 };

// 结构体
struct A
{
    int x;
    int y;
} a = {1, 2};

C++11中，列表初始化的范围增大了，现在它可以用于任何类型对象的初始化：

class Foo
{
public:
    Foo(int) {}
};

int main()
{
    Foo a1(23);        // 常规的初始化
    Foo a2 = { 123 };  // 列表初始化,虽然有=，但是也是初始化
    Foo a3 { 123 };    // 与a2等价

    int b1 = { 3 };
    int b2{ 3 };     // 列表初始化

    int c1[3]{ 1,2,3 };

    // POD类型的初始化  
    // plain old data , 可以直接使用memcpy复制的对象
    struct A
    {
        int x;
        struct B
        {
            float y;
            float z;
        } b;
    };

    A a = { 2, {2.3, 4.4} };
    A b { 2,{ 2.3, 4.4 } };

    // 指针初始化
    int* d1 = new int{ 12 };
    int* arr = new int[3] { 1,2,4 };


    return 0;
}

// 列表初始化可以直接使用在函数的返回值上面
struct Value
{
    int x;
    int y;
    Value(int x, int y) {}
};

Value func()
{
    return {12, 22};
}

列表初始化中的一些细节问题：
在这里需要区分一下：列表初始化被用于自定义类型的时候：
1. 自定义的类型中没有构造函数

聚合类型初始化，以拷贝的形式，用初始化列表中的值来初始化成员

// 结构体
struct A
{
    int x;
    int y;
} a = {1, 2};    // C++98 聚合类型初始化

2. 自定义的类型中有构造函数

利用构造函数进行初始化

struct B
{
    int x;
    int y;
    B(int x, int y) {}
} b = {1, 2};

在使用列表初始化时，如果类型满足以下的条件，C++会认为它是一个聚合体：
1. 类型是普通的数组

2. 类型是一个类，且满足：

a. 没有自定义的构造函数

b. 没有基类

c. 没有虚函数

d. 没有private或者protected的非静态数据成员(也就是说非静态的数据成员不能是private或者protected)

e. 不能有{}和=直接初始化的非静态数据成员

例如：

// 有private或者protected的数据成员
struct ST
{
    int x;
    int y;
private:
    int z;
};

ST s(1, 2, 3);   // invalid 

// 有private或者protected的静态数据成员
struct SU
{
    int x;
    int y;
protected:
    static int z;
};

SU s(1, 2);   // valid protected的时静态数据成员

// 有== {} 初始化的非静态数据成员
struct SN
{
    int x;
    int y = 3;
};

SN s(1, 4);

对于非聚合类型的对象，如果需要使用列表初始化，就需要自定义构造函数才可以.

聚合类型的定义是非递归的：当一个类的非静态成员是非聚合类型的时候，这个类也有可能是聚合类型。

例如：

struct ST
{
    int x;
    double y;
private:
    int z;
};

struct Foo
{
    ST st;    // 非聚合类型
    int x;
    double y;
};

// 初始化
Foo foo{ {}, 1, 2.4 };     // 第一个{}相当于调用ST的无参构造函数

所以，列表初始话的过程可以总结为：对于聚合类型，使用初始化列表相当于对其中的每个元素分别赋值；对于非聚合类型，则需要先定义一个合适的构造函数，是用初始化列表相当于调用对应的构造函数。

STL中的容器也支持初始化列表的操作，例如：

// 初始化列表
int arr[] {1,3,4};
// container
std::map<std::string, int> mp = { {"a", 2}, {"b", 4}, {"c", 6} };
std::set<int> ss {1,2,3,4};
std::vector<int> v {1,2,3,4};

STL中的容器是通过使用std::initializer_list实现对初始化列表的支持的，std::initializer_lis用来接收传进来的参数，然后将接收到的参数传入到容器中，例如，自定义一个容器：

// ConsoleApplication1.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include <iostream>
#include <memory>
#include <map>
#include <vector>

class myVector
{
private:
    std::vector<int> content;

public:
    myVector(std::initializer_list<int> list)    //构造函数
    {
        // 使用初始化列表相当于调用构造函数， 构造函数将传进来数据进行处理
        for (auto iter = list.begin(); iter != list.end(); iter++)
        {
            // 将list中的数据放入容器
            content.push_back(*iter);
        }
    }
};


class myMap
{
private:
    std::map<std::string, int> content;

public:
    using pair_t = std::map<std::string, int>::value_type;   // using重定义  pair的类型
    myMap(std::initializer_list<pair_t> list)
    {
        for (auto iter = list.begin(); iter != list.end(); iter++)
        {
            content.insert(*iter);
        }
    }

};


int main()
{
    myVector v1 {1,2,3,4};
    myMap mp1{ {"a", 1},{"b", 2},{"c", 3} };
    return 0;
}

通过上述的方法，了解了std::initializer_list的工作原理，它用来接受初始化列表，此外，它还可以作为函数的参数进行传递，例如：（传递同类型参数）

template<typename T>
void func(std::initializer_list<T> l)
{
    for (auto iter = l.begin(); iter != l.end(); iter++)
    {
        std::cout << *iter << " ";
    }
    std::cout << std::endl;
}

int main()
{
    func({ "hello","ya","oaix" });
    return 0;
}

std::initializer_list的细节介绍：

1. 首先，它是一个轻量级的容器，内部定义了iterator等容器必须的概念

2.他可以按照任意的长度接受初始化列表，但是列表中的元素必须是同一种类型的

3.3个成员接口，begin， end, size

4. 只能被整体初始化或者赋值

5. 返回的迭代器是只读的，不能用返回的迭代器对元素进行修改

实际上，std::initializer_list的效率是非常高的，因为他保存的不是初始化列表中元素的拷贝，而实元素的引用，所以不能用于函数返回值

防止类型收窄：

除了上面介绍的功能之外，初始化列表还有一个作用，那就是防止类型收窄，在以下的几种情况中，会出现类型收窄：
1. 从浮点隐式的转化为整数

’2.从高精度隐式的转化为低精度

3. 从整型数隐式的转化为浮点数，并且超出了浮点数的范围

4. 从整型数隐式的转化为一个长度较短的整型数，且超出了范围

如果使用初始化列表，就可以防止上述的错误：

int a = 1.1;   // ok
int b {1.2};   // 报错

float fa = 1e40; // ok
float fb {1e40}; // 报错 超出范围


int x = 1024;

char y = x;   //ok
char z {x};   // 报错

只要遇到类型收窄的情况，初始化列表就会报错。