C11 列表初始化、左/右值引用、移动语义、可变参数模版

std::initializer_list 是C++11引入的一种特殊类型，它能够存储一组指定类型的常量值序列，并提供迭代器访问这些值。下面是一个示例说明其类型：

int main()
{
    // il 的类型即为 std::initializer_list<int>
    auto il = { 10, 20, 30 };
    cout << typeid(il).name() << endl;
    return 0;
}

std::initializer_list 主要用于简化构造函数参数的传递，尤其是在初始化容器对象时。C++11标准库中的许多容器如 std::vector, std::list, std::map 等都增加了接受 std::initializer_list 类型参数的构造函数，使得我们可以方便地用花括号列表来初始化容器。

例如：

int main()
{
    // 使用 std::initializer_list 初始化容器
    std::vector<int> v = { 1, 2, 3, 4 };
    std::list<int> lt = { 1, 2 };

    // 使用 std::initializer_list 初始化 map，其中每个元素都会被解释为 pair
    std::map<std::string, std::string> dict = { { "sort", "排序" }, { "insert", "插入" } };

    // 同样支持大括号对容器进行赋值操作
    v = { 10, 20, 30 };

    return 0;
}

3、模拟实现vector花括号操作

为了使我们自定义的 `bit::vector` 支持花括号初始化以及赋值操作，可以如下实现：

namespace bit
{
    template <class T>
    class vector {
    public:
        typedef T* iterator;

        // 构造函数接收 std::initializer_list 参数
        vector(std::initializer_list<T> l)
        {
            _start = new T[l.size()];
            _finish = _start + l.size();
            _endofstorage = _start + l.size();

            iterator vit = _start;
            typename std::initializer_list<T>::iterator lit = l.begin();

            // 遍历并复制 initializer_list 中的元素到新建的 vector 中
            while (lit != l.end()) {
                *vit++ = *lit++;
            }
        }

        // 赋值运算符重载，接收 std::initializer_list 参数
        vector<T>& operator=(std::initializer_list<T> l) {
            // 创建临时对象，并用新的 initializer_list 初始化
            vector<T> tmp(l);

            // 通过 swap 技术完成赋值（避免自我赋值问题）
            std::swap(_start, tmp._start);
            std::swap(_finish, tmp._finish);
            std::swap(_endofstorage, tmp._endofstorage);

            return *this;
        }

    private:
        iterator _start;
        iterator _finish;
        iterator _endofstorage;
    };
}

在C++11中，引入了多种简化声明的方式，特别是在模板编程中大大提高了效率和可读性。

1、自动类型推断 - auto

自动类型推断 - auto 在C++98中，auto关键字表示变量具有局部作用域和自动存储期，但由于局部变量默认就是自动存储类型，所以当时的auto显得并不重要。然而，在C++11中，auto的含义发生了改变，它被用来实现自动类型推断。这意味着当你声明一个变量并使用auto时，编译器会根据初始化表达式自动推断出该变量的类型，因此必须进行显式初始化。

示例：

int main()
{
    int i = 10;
    auto p = &i;  // p 的类型被推断为 int*
    auto pf = strcpy; // pf 的类型被推断为 char* (*)(char*, const char*)

    cout << typeid(p).name() << endl;
    cout << typeid(pf).name() << endl;

    map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
    // 使用auto简化迭代器声明
    // map<string, string>::iterator it = dict.begin();
    auto it = dict.begin(); // it 的类型被推断为 map<string, string>::iterator

    return 0;
}

2、类型推导关键字 - decltype

`decltype` 关键字允许你声明变量的类型与指定表达式的结果类型相同，这对于理解复杂的模板类型或推断函数返回类型极其有用。

// decltype 的应用场景
template <class T1, class T2>
void F(T1 t1, T2 t2)
{
    decltype(t1 * t2) ret; // ret 的类型由 t1 和 t2 相乘决定
    cout << typeid(ret).name() << endl;
}

int main()
{
    const int x = 1;
    double y = 2.2;
    decltype(x * y) ret; // ret 的类型被推断为 double
    decltype(&x) p;      // p 的类型被推断为 int*

    cout << typeid(ret).name() << endl;
    cout << typeid(p).name() << endl;

    F(1, 'a'); // 根据传入参数推断 ret 的类型

    return 0;
}

// 在C++11及以上版本中，建议使用nullptr代替NULL
void* ptr = nullptr;

4、范围for循环

范围for循环 C++11引入了范围for循环，这是一种更简洁的方式来遍历任何可迭代的对象，包括但不限于STL容器。它的语法格式如下：

for (declaration : range-expression)
    statement

例如，对于上述提到的dict容器，我们可以用范围for循环遍历：

for (const auto& pair : dict)
{
    cout << pair.first << ": " << pair.second << endl;
}

在这个循环中，编译器会自动获取dict的迭代器，并按顺序遍历容器中的每个元素，无需手动管理迭代器。每次迭代时，pair会被隐式声明为一个引用，引用当前迭代到的键值对。