【Cpp】第十九章-Cpp11新特性

Cpp11新特性

  Cpp11中新增了很多新的语法，很多之前我们都已经有介绍过

初始化列表

如何使用

  在Cpp11中允许使用初始化列表初始化任何类型，不论是内置类型还是自定义类型都可以使用初始化列表进行初始化，而在Cpp98的版本中是不能初始化自定义类型的。

#include <iostream>
#include <vector>
class Test
{
public:
    Test(int a, int b)
        :_a(a)
        ,_b(b)
    {
    }
    void Print()
    {
        std::cout << _a << " " << _b << std::endl;
    }
private:
    int _a;
    int _b;
};
int main()
{
    //内置类型的初始化列表初始化
    int a = {10};
    int b = {3 + 4};
    std::cout << a << " " << b << std::endl;
    int arr[] = {1, 2, 3, 4};
    for(int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
    //自定义类型初始化列表初始化
    std::vector<int> arr2 = {4, 3, 2, 1};
    for(auto e : arr2)
    {
        std::cout << e << " ";
    }
    std::cout << std::endl;
    Test test = {7, 8};
    test.Print();
}



10 7
1 2 3 4
4 3 2 1
7 8

initializer_list

  但是自定义类型想要支持像vector这样的初始化列表并不是天然就支持的，而是在Cpp11中新增了一个容器叫initializer_list，初始化列表，借助这个容器我们可以实现vector这样的初始化。

#include <iostream>
#include <vector>
class Test
{
public:
    Test(int a, int b)
        :_a(a)
        ,_b(b)
    {
    }
    void Print()
    {
        std::cout << _a << " " << _b << std::endl;
    }
private:
    int _a;
    int _b;
};
template<class T>
class Vector
{
public:
    Vector(size_t n = 0)
        :_start(new T[n])
        ,_finish(_start + n)
        ,_endOfStorge(_start + n)
    {
    }
    //我们想要使用初始化列表初始化vector多亏下面这样的构造函数
    Vector(const std::initializer_list<T>& list)//初始化列表容器
        :_start(new T[list.size()])
        ,_finish(_start + list.size())
        ,_endOfStorge(_start + list.size())
    {
        //std::initializer_list容器有三个公有接口，start(), end()提供遍历，size()提供大小
        int index = 0;
        for(auto e : list)
        {
            _start[index] = e;
            index++;
        }   
    }
    void Print()
    {
        T* start = _start;
        while(start != _finish)
        {
            std::cout << *start << " ";
            start++;
        }
        std::cout << std::endl;
    }
private:
    T* _start;
    T* _finish;
    T* _endOfStorge;
};
int main()
{
    Vector<int> vec = {1, 2, 3, 4, 5};
    vec.Print();
}


1 2 3 4 5

  因此如果我们在自己今后写自定义类型时，想要在初始化时利用初始化列表进行不定长参数的初始化时，就可以借助initializer_list来实现。
  如果我们想让一个自定义类型不再支持初始化列表进行初始化我们也可以通过加explicit关键字来禁用。

变量类型推导

  变量类型推导其中的典型代表就是我们一直在使用的auto关键字，它可以帮助我们简化代码书写，一些很复杂的类型一个auto即可代替，但是auto是编译时类型识别，除此之外还有一个关键字这里要提一下，即decltype，这个关键字我们之前并没有使用过，不过这个关键字是RTTI的，它可以在运行时进行类型识别。
  auto和decltype之间最显著的差别就是，auto在编译时就将变量类型确定下来，因此如果我们声明一个变量而不去定义它