《探秘C++》No.23 C++11（一）-阿里云开发者社区

C++11作为C++语言的重要更新版本，引入了许多令人兴奋的新特性和语法。这些新特性在现代编程领域中发挥着重要作用，使得C++语言更加强大、灵活和易用。

在这篇博客中，我们将深入探讨C++11中一些新增加的语法，包括但不限于：

自动类型推导（auto关键字）
区间遍历（range-based for循环）
Lambda表达式和函数对象
移动语义和右值引用

通过学习这些新增加的语法，你将能够更好地理解C++11的特性，并且能够在实际项目中应用它们，提高代码的质量和效率。

无论你是C++初学者还是有经验的开发者，这篇博客都将为你带来价值。让我们一起探索C++11的新边界，开启现代编程的全新旅程！

1.C++11简介

在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习。C++11增加的语法特性非常篇幅非常多，我们这里没办法一一讲解，所以本节课程主要讲解实际中比较实用的语法。

C++11的介绍文档

https://en.cppreference.com/w/cpp/11

小故事：

1998年是C++标准委员会成立的第一年，本来计划以后每5年视实际需要更新一次标准，C++国际标准委员会在研究C++ 03的下一个版本的时候，一开始计划是2007年发布，所以最初这个标准叫C++ 07。但是到06年的时候，官方觉得2007年肯定完不成C++ 07，而且官方觉得2008年可能也完不成。最后干脆叫C++ 0x。x的意思是不知道到底能在07还是08还是09年完成。结果2010年的时候也没完成，最后在2011年终于完成了C++标准。所以最终定名为C++11。

2.列表初始化

2.1 { } 初始化

在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：

struct Point
{
    int _x;
    int _y;
};
int main()
{
    int array1[] = { 1, 2, 3, 4, 5 };
    int array2[5] = { 0 };
    Point p = { 1, 2 };
    return 0;
}

C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

struct Point
{
    int _x;
    int _y;
};
int main()
{
    int x1 = 1;
    //下面几种要求能看懂，但是不建议使用
    int x2{ 2 };
    int array1[]{ 1, 2, 3, 4, 5 };
    int array2[5]{ 0 };
    Point p{ 1, 2 };
    // C++11中列表初始化也可以适用于new表达式中
    int* pa = new int[4]{ 0 };
    return 0;
}

创建对象时也可以使用列表初始化方式调用构造函数初始化

class Date
{
    public:
    Date(int year, int month, int day)
        :_year(year)
         ,_month(month)
         ,_day(day)
   {
       cout << "Date(int year, int month, int day)" << endl;
   }
    private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1(2022, 1, 1); // old style 
    // C++11支持的列表初始化，这里会调用构造函数初始化
    Date d2{ 2022, 1, 2 };
    Date d3 = { 2022, 1, 3 };
    vector<Date> v1={d1,d2,d3};
    vector<Date> v2={{2022, 1, 1},{ 2022, 1, 2 },{ 2022, 1, 3 }};//相当于隐式类型转换
    string s1="11111";
    //构造
    map<string,string> dict={{"sort","排序"},{"insert","排序"}}；//相当于调用两次make_pair构造，然后再initializer_list初始化
    //赋值重载
    initializer_list<pair<const string,string>> kvil={{"left","左边"}};//比较复杂、严格
    dict=kvil;
    return 0;
}

2.2 std::initializer_list

std::initializer_list的介绍文档：

http://www.cplusplus.com/reference/initializer_list/initializer_list/

std::initializer_list是什么类型：

int main()
{
    // the type of il is an initializer_list
    //容器支持调用list (initializer_list<value_type> il)这样类似的构造函数
    auto il = { 10, 20, 30 };
    cout << typeid(il).name() << endl;
    return 0;
}

std::initializer_list使用场景：

std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加

std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值。

所有的容器都支持这样一个构造函数，所以我们可以使用列表初始化。

如下：

http://www.cplusplus.com/reference/list/list/list/

http://www.cplusplus.com/reference/vector/vector/vector/

http://www.cplusplus.com/reference/map/map/map/

http://www.cplusplus.com/reference/vector/vector/operator=/

int main()
{
    vector<int> v = { 1,2,3,4 };
    list<int> lt = { 1,2 };
    // 这里{"sort", "排序"}会先初始化构造一个pair对象
    map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
    // 使用大括号对容器赋值
    v = {10, 20, 30};
    return 0;
}

让我们之前模拟实现的vector也支持{}初始化和赋值

之前写的vector模拟实现的博客☞《vector模拟实现》

向之前代码中插入下面的代码即可支持列表初始化

namespace bit
{
    template<class T>
        class vector {
            public:
            typedef T* iterator;
            vector(initializer_list<T> il)
                :_start(nullptr)
                ,_finish(nullptr)
                ,_end_of_storage(nullptr)
            {
                reserve(il.size());//提前开好空间
                for(auto & e : il)
                {
                    push_back(e);
                }
            }
            vector<T>& operator=(initializer_list<T> l) {
                vector<T> tmp(l);
                std::swap(_start, tmp._start);
                std::swap(_finish, tmp._finish);
                std::swap(_endofstorage, tmp._endofstorage);
                return *this;
            }
            private:
            iterator _start;
            iterator _finish;
            iterator _endofstorage;
        };
}

2.3 总结

C++11以后一切对象都可以用列表初始化，但是建议普通对象还是用以前的方式初始化，容器如果有需要可以用列表初始化

3.声明

c++11提供了多种简化声明的方式，尤其是在使用模板时。

3.1 auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。

C++11中废弃auto原来的用法，将其用于实现自动类型推断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

int main()
{
    int i = 10;
    auto p = &i;
    auto pf = strcpy;
    cout << typeid(p).name() << endl;
    cout << typeid(pf).name() << endl;
    map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
    //map<string, string>::iterator it = dict.begin();
    auto it = dict.begin();
    return 0;
}

总结：带来了便捷，也降低了代码的可读性。

3.2 decltype

关键字decltype将变量的类型声明为表达式指定的类型。

// decltype的一些使用使用场景
template<class T1, class T2>
 void F(T1 t1, T2 t2)
{
    decltype(t1 * t2) ret=t1*t2;//推导类型，然后定义
    cout << typeid(ret).name() << endl;
    //typeid拿到的只是类型的字符串，但是不能用它去定义对象
}
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');
    return 0;
}

3.3 nullptr

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示

整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

#ifndef NULL
#ifdef __cplusplus
#define NULL  0
#else
#define NULL  ((void *)0)
#endif
#endif

4.范围for循环

这个我们在前面的课程中已经进行了非常详细的讲解，这里就不进行讲解了，请参考C++入门

5.新增加容器—静态数组array、forward_list以及unordered系列

新容器

用橘色圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered_map和unordered_set。这两个我们前面已经进行了非常详细的讲解，我们现在简单讲一下array和forward_list。

两个字形容“鸡肋”

C++11增加array的初衷是什么，替代C语言中的数组，让数组容器化，C语言数组不好在哪里？对越界的检查，越界读基本检查不出来，越界写是抽查（看情况）。但是容器化后，越界读写都可以检查出来，因为它调用的是oprator[]函数，进来就检查下标是否越界,可是array用的很少，这是为什么呢？一方面是c语言用惯了，第二就是用array不如用vector+resize去替代c数组.

forward_list是单链表，对比list就是减少使用空间，但是平时使用的时候难道会差一个指针吗？使用list不香吗，所以也比较鸡肋

容器中的一些新方法

如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得比较少的。

比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操作。

实际上C++11更新后，容器中增加的新方法最后用的插入接口函数的右值引用版本：

如下列接口函数：

http://www.cplusplus.com/reference/vector/vector/emplace_back/

http://www.cplusplus.com/reference/vector/vector/push_back/

http://www.cplusplus.com/reference/map/map/insert/

http://www.cplusplus.com/reference/map/map/emplace/

但是这些接口到底意义在哪？网上都说他们能提高效率，他们是如何提高效率的？

请看下面的右值引用和移动语义章节的讲解。

6.右值引用

6.1 左值引用和右值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

什么是左值？什么是左值引用？

左值是一个表示数据的表达式(如变量名或解引用的指针)，**我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。**左值引用就是给左值的引用，给左值取别名。

int main()
{
    // 以下的p、b、c、*p都是左值
    int* p = new int(0);
    int b = 1;
    const int c = 2;
    // 以下几个是对上面左值的左值引用
    int*& rp = p;
    int& rb = b;
    const int& rc = c;
    int& pvalue = *p;
    return 0;
}

什么是右值？什么是右值引用？

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引

用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能

**取地址。**右值引用就是对右值的引用，给右值取别名。

1、内置类型右值-纯右值

2、自定义类型右值-将亡值

int main()
{
    double x = 1.1, y = 2.2;
    // 以下几个都是常见的右值
    10;
    x + y;
    fmin(x, y);
    // 以下几个都是对右值的右值引用
    int&& rr1 = 10;
    double&& rr2 = x + y;
    double&& rr3 = fmin(x, y);
    // 这里编译会报错：error C2106: “=”: 左操作数必须为左值
    10 = 1;
    x + y = 1;
    fmin(x, y) = 1;
    return 0;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可

以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地

址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用，是不是感觉很神奇，

这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。

int main()
{
    double x = 1.1, y = 2.2;
    int&& rr1 = 10;
    const double&& rr2 = x + y;
    rr1 = 20;
    rr2 = 5.5;  // 报错
    return 0;
}

6.2 左值引用与右值引用比较

左值引用总结：

左值引用只能引用左值，不能引用右值。

但是const左值引用既可引用左值，也可引用右值。

int main()
{
    // 左值引用只能引用左值，不能引用右值。
    int a = 10;
    int& ra1 = a;  // ra为a的别名
    //int& ra2 = 10;  // 编译失败，因为10是右值
    // const左值引用既可引用左值，也可引用右值。
    const int& ra3 = 10;
    const int& ra4 = a;
    return 0;
}

右值引用总结：

右值引用只能右值，不能引用左值。

但是右值引用可以move以后的左值。

int main()
{
    // 右值引用只能右值，不能引用左值。
    int&& r1 = 10;
    // error C2440: “初始化”: 无法从“int”转换为“int &&”
    // message : 无法将左值绑定到右值引用
    int a = 10;
    int&& r2 = a;
    // 右值引用可以引用move以后的左值
    int&& r3 = std::move(a);
    return 0;
}

6.3 右值引用使用场景和意义

前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢？是不是化蛇添足呢？

左值引用解决那些问题？

做参数。
a. 减少拷贝，提高效率
b. 做输出型参数

做返回值。
a. 减少拷贝，提高效率
b. 引用返回，可以修改返回对象（比如：operator[])。

但是左值引用就没有缺陷吗？当然有，否则要右值引用干嘛，它做返回值时还有一些问题没有解决。

C++98的左值引用面向下面的场景很难处理：

C++右值引用的一个重要作用就是解决上面问题

下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！

namespace hxq
{
    class string
    {
        public:
        typedef char* iterator;
        iterator begin()
        {
            return _str;
        }
        iterator end()
        {
            return _str + _size;
        }
        string(const char* str = "")
            :_size(strlen(str))
                , _capacity(_size)
            {
                //cout << "string(char* str)" << endl;
                _str = new char[_capacity + 1];
                strcpy(_str, str);
            }
        // s1.swap(s2)
        void swap(string& s)
        {
            ::swap(_str, s._str);
            ::swap(_size, s._size);
            ::swap(_capacity, s._capacity);
        }
        // 拷贝构造
        string(const string& s)
            :_str(nullptr)
            {
                cout << "string(const string& s) -- 深拷贝" << endl;
                string tmp(s._str);
                swap(tmp);
            }
        // 赋值重载
        string& operator=(const string& s)
        {
            cout << "string& operator=(string s) -- 深拷贝" << endl;
            string tmp(s);
            swap(tmp);
            return *this;
        }
        // 移动构造
        string(string&& s)
            :_str(nullptr)
            ,_size(0)
            ,_capacity(0)
            {
                cout << "string(string&& s) -- 移动语义" << endl;
                swap(s);
            }
        // 移动赋值
        string& operator=(string&& s)
        {
            cout << "string& operator=(string&& s) -- 移动语义" << endl;
            swap(s);
            return *this;
        }
        ~string()
        {
            delete[] _str;
            _str = nullptr;
        }
        char& operator[](size_t pos)
        {
            assert(pos < _size);
            return _str[pos];
        }
        void reserve(size_t n)
        {
            if (n > _capacity)
            {
                char* tmp = new char[n + 1];
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
                _capacity = n;
            }
        }
        void push_back(char ch)
        {
            if (_size >= _capacity)
            {
                size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
                reserve(newcapacity);
            }
            _str[_size] = ch;
            ++_size;
            _str[_size] = '\0';
        }
        //string operator+=(char ch)
        string& operator+=(char ch)
        {
            push_back(ch);
            return *this;
        }
        const char* c_str() const
        {
            return _str;
        }
        private:
        char* _str;
        size_t _size;
        size_t _capacity; // 不包含最后做标识的\0
    };
}

左值引用的使用场景：

做参数和做返回值都可以提高效率。

void func1(bit::string s)
{}
void func2(const bit::string& s)
{}
int main()
{
    hxq::string s1("hello world");
    // func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
    func1(s1);
    func2(s1);
    // string operator+=(char ch) 传值返回存在深拷贝
    // string& operator+=(char ch) 传左值引用没有拷贝提高了效率
    s1 += '!';
    return 0;
}

左值引用的短板：

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，

**只能传值返回。**例如：bit::string to_string(int value)函数中可以看到，这里只能使用传值返回，

传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

namespace hxq
{
    bit::string to_string(int value)
    {
        bool flag = true;
        if (value < 0)
        {
            flag = false;
            value = 0 - value;
        }
        bit::string str;
        while (value > 0)
        {
            int x = value % 10;
            value /= 10;
            str += ('0' + x);
        }
        if (flag == false)
        {
            str += '-';
        }
        std::reverse(str.begin(), str.end());
        return str;
    }
}
int main()
{
    // 在hxq::string to_string(int value)函数中可以看到，这里
    // 只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
    hxq::string ret1 = hxq::to_string(1234);
    hxq::string ret2 = hxq::to_string(-1234);
    return 0;
}

右值引用和移动语义解决上述问题：

在bit::string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不

用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。

// 移动构造
string(string&& s)
    :_str(nullptr)
    ,_size(0)
    ,_capacity(0)
    {
        cout << "string(string&& s) -- 移动语义" << endl;
        swap(s);
    }
int main()
{
    hxq::string ret2 = hxq::to_string(-1234);
    return 0;
}

再运行上面hxq::to_string的两个调用，我们会发现，这里没有调用深拷贝的拷贝构造，而是调用

了移动构造，移动构造中没有新开空间，拷贝数据，所以效率提高了。

不仅仅有移动构造，还有移动赋值：

在hxq::string类中增加移动赋值函数，再去调用hxq::to_string(1234)，不过这次是将

hxq::to_string(1234)返回的右值对象赋值给ret1对象，这时调用的是移动构造。

// 移动赋值
string& operator=(string&& s)
{
    cout << "string& operator=(string&& s) -- 移动语义" << endl;
    swap(s);
    return *this;
}
int main()
{
    hxq::string ret1;
    ret1 = hxq::to_string(1234);
    return 0;
}
// 运行结果：
// string(string&& s) -- 移动语义
// string& operator=(string&& s) -- 移动语义

这里运行后，我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象接收，编译器就没办法优化了。hxq::to_string函数中会先用str生成构造生成一个临时对象，但是我们可以看到，编译器很聪明的在这里把str识别成了右值，调用了移动构造。然后在把这个临时对象做为hxq::to_string函数调用的返回值赋值给ret1，这里调用的移动赋值。

STL中的容器都是增加了移动构造和移动赋值：

http://www.cplusplus.com/reference/string/string/string/

http://www.cplusplus.com/reference/vector/vector/vector/

6.4 右值引用引用左值及其一些更深入的使用场景分析

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？

因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

template<class _Ty>
    inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
    {
        // forward _Arg as movable
        return ((typename remove_reference<_Ty>::type&&)_Arg);
    }

int main()
{
    hxq::string s1("hello world");
    // 这里s1是左值，调用的是拷贝构造
    hxq::string s2(s1);
    // 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
    // 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
    // 资源被转移给了s3，s1被置空了。
    hxq::string s3(std::move(s1));
    return 0;
}

STL容器插入接口函数也增加了右值引用版本：

http://www.cplusplus.com/reference/list/list/push_back/

http://www.cplusplus.com/reference/vector/vector/push_back/

void push_back (value_type&& val);
int main()
{
    list<hxq::string> lt;
    hxq::string s1("1111");
    // 这里调用的是拷贝构造
    lt.push_back(s1);
    // 下面调用都是移动构造
    lt.push_back("2222");
    lt.push_back(std::move(s1));
    return 0;
}
运行结果：
    // string(const string& s) -- 深拷贝
    // string(string&& s) -- 移动语义
    // string(string&& s) -- 移动语义

6.5 完美转发

模板中的&& 万能引用

void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
void Fun(int &&x){ cout << "右值引用" << endl; }
void Fun(const int &&x){ cout << "const 右值引用" << endl; }
// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
template<typename T>
void PerfectForward(T&& t)
{
    Fun(t);
}
int main()
{
    PerfectForward(10);      // 右值
    int a;
    PerfectForward(a);       // 左值
    PerfectForward(std::move(a)); // 右值
    const int b = 8;
    PerfectForward(b);    // const 左值
    PerfectForward(std::move(b)); // const 右值
    return 0;
}

std::forward 完美转发在传参的过程中保留对象原生类型属性

void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
void Fun(int &&x){ cout << "右值引用" << endl; }
void Fun(const int &&x){ cout << "const 右值引用" << endl; }
// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
template<typename T>
void PerfectForward(T&& t)
{
    Fun(std::forward<T>(t));
}
int main()
{
    PerfectForward(10);      // 右值
    int a;
    PerfectForward(a);       // 左值
    PerfectForward(std::move(a)); // 右值
    const int b = 8;
    PerfectForward(b);    // const 左值
    PerfectForward(std::move(b)); // const 右值
    return 0;
}

完美转发实际中的使用场景：

template<class T>
    struct ListNode
    {
        ListNode* _next = nullptr;
        ListNode* _prev = nullptr;
        T _data;
    };
template<class T>
    class List
    {
        typedef ListNode<T> Node;
        public:
        List()
        {
            _head = new Node;
            _head->_next = _head;
            _head->_prev = _head;
        }
        void PushBack(T&& x)
        {
            //Insert(_head, x);
            Insert(_head, std::forward<T>(x));
        }
        void PushFront(T&& x)
        {
            //Insert(_head->_next, x);
            Insert(_head->_next, std::forward<T>(x));
        }
        void Insert(Node* pos, T&& x)
        {
            Node* prev = pos->_prev;
            Node* newnode = new Node;
            newnode->_data = std::forward<T>(x); // 关键位置
            // prev newnode pos
            prev->_next = newnode;
            newnode->_prev = prev;
            newnode->_next = pos;
            pos->_prev = newnode;
        }
        void Insert(Node* pos, const T& x)
        {
            Node* prev = pos->_prev;
            Node* newnode = new Node;
            newnode->_data = x; // 关键位置
            // prev newnode pos
            prev->_next = newnode;
            newnode->_prev = prev;
            newnode->_next = pos;
            pos->_prev = newnode;
        }
        private:
        Node* _head;
    };
int main()
{
    List<hxq::string> lt;
    lt.PushBack("1111");
    lt.PushFront("2222");
    return 0;
}

《探秘C++》No.23 C++11（二）+https://developer.aliyun.com/article/1389765

《探秘C++》No.23 C++11（一）

1.C++11简介

2.列表初始化

2.1 { } 初始化

2.2 std::initializer_list

2.3 总结

3.声明

3.1 auto

3.2 decltype

3.3 nullptr

4.范围for循环

5.新增加容器—静态数组array、forward_list以及unordered系列

6.右值引用

6.1 左值引用和右值引用

6.2 左值引用与右值引用比较

6.3 右值引用使用场景和意义

6.4 右值引用引用左值及其一些更深入的使用场景分析

6.5 完美转发

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

《探秘C++》No.23 C++11（一）

1.C++11简介

2.列表初始化

2.1 { } 初始化

2.2 std::initializer_list

2.3 总结

3.声明

3.1 auto

3.2 decltype

3.3 nullptr

4.范围for循环

5.新增加容器—静态数组array、forward_list以及unordered系列

6.右值引用

6.1 左值引用和右值引用

6.2 左值引用与右值引用比较

6.3 右值引用使用场景和意义

6.4 右值引用引用左值及其一些更深入的使用场景分析

6.5 完美转发

热门文章

最新文章

相关课程

相关电子书