• C++11新特性介绍 02

    1. 范围for语句

    C++11 引入了一种更为简单的for语句，这种for语句可以很方便的遍历容器或其他序列的所有元素

    1
    2
    3
    4
    5
    vector<int> vec = {1,2,3,4,5,6};
    for(int x: vec)
    {
        cout<<x<<endl;
    }

    2. 尾置返回类型

    要想引入尾置类型，我们还得从复杂的类型声明说起。如果我们需要定义一个含有10个int元素的数组，一般是这样的：

    1
    int arr[10] = {0};

    如果要定义指向这个数组的指针呢：

    1
    int (*p_arr)[10] = &arr; //注意：int *p_arr[10] 表示一个数组，有10个元素，元素类型是int*

    如果要定义一个函数，这个函数接受一个char类型的参数，并返回一个指向10个int类型数组的指针呢：

    1
    int (*func(char x))[10];

    这样的声明是不是看的头都大了，其实我们可以简化一点，一般情况下我们可以使用别名进行简化，比如：

    1
    2
    typedef int ARR[10] ; // 定义一个类型 ARR这是一个数组类型，含有10个int类型的元素
    using ARR = int[10] ; // 同上

    再定义如上的函数：

    1
    ARR * func(char x) ; // 函数返回的类型是 ARR* 也就是指向具有10个int元素数组的指针

    当然在C++11中我们可以用之前讲到过的另外一个关键字decltype：

    1
    decltype(arr) * func(char x) ; // decltype(arr)表达式会获得arr的类型

    最后就轮到我们本节要说的C++11的另外一个特性，尾置返回类型，任何函数都可以使用尾置返回类型，这种形式对于返回类型比较复杂的函数最有效，比如上面的函数可以使用如下方式：

    1
    auto func(char x) -> int(*) [10];

    这种形式将函数的返回类型写在函数声明的最后面，并且在函数形参列表后面加上 -> 符号，然后紧接着是函数需要返回的类型，由于函数的返回类型被放在了形参列表之后，所以在函数名前面使用一个 auto替代。

    3. =default 生成默认构造函数

    在C++的类中，如果我们没有定义构造函数，编译器会为我们合成默认的无参构造函数，如果我们定义了构造函数，则编译器就不生成默认构造函数了，但是如果我们定义构造函数同时也希望编译器生成默认构造函数呢? C++11中可以通过在构造函数的声明中直接  =default的方式要求编译器生成构造函数。

    1
    2
    3
    4
    5
    class ClassName{
        public:
            ClassName(int x);
            ClassName()=default; // 显示要求编译器生成构造函数
    };

    4. 类对象成员的类内初始化

    1
    2
    3
    4
    5
    class ClassName
    {
            public:
                    int x = 10; //C++11 之前是不允许的
    };

    5. lambda表达式与bind函数

    lambda表达式是一个可以被调用的代码单元，相当于一个内联函数，有参数和返回值以及函数体。但是跟函数不同的是，lambda表达式可以定义在函数的内部，一个完整的lambda表达式具有如下形式：

    [捕获列表](参数列表) mutable -> 返回类型 {函数体}

    1
    2
    3
    4
    5
    int x = 10;
    int y = 20;
    auto f = [x,&y](int a ,int b){++y;return a+b+x+y;};
    cout<<f(1,2)<<endl; //34
    cout<<y<<endl;      //21

    lambda可以省略参数列表(如果没有参数的话)，可以省略返回类型，但是不能省略捕获部分与函数体部分，即使捕获列表为空,也要有一个空的[]，lambda有两种捕获，一种是值捕获，一种是引用捕获。如果是值捕获那么lambda中获得的是捕获的变量的副本，如果是引用捕获则获得的是引用，可以在lambda内部修改引用的变量的值，如上x是值捕获，y是引用捕获，lambda中默认是值捕获，如果变量前面添加&则是引用捕获，另外lambda中还有两种形式的引用捕获，例如[=]表示值捕获所有可见的变量，而[&]则表示引用捕获所有可见变量。如果希望值捕获所有可见变量，但是又有个别变量采用引用捕获呢，[=,&x]表示值捕获所有可见变量，同时引用捕获x。而[&,x]则表示引用捕获所有可见变量，x采用值捕获的方式。

    有关bind函数，在很多地方我们可以使用函数替换lambda表达式，毕竟如果很多地方需要用到同一个lambda表达式，而且这个lambda表达式比较长的话，将其定义成函数应该是最好的。对于没有捕获列表的lambda表达式我们可以直接使用函数替代，例如：

    1
    2
    3
    4
    5
    void main()
    {
        auto f=[](int x,int y){return x+y};
        f();
    }

    我们可以用下面的方式替代：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    int f(int x,int y)
    {
       return x+y;
    }
     
    void main()
    {
        f();
    }

    与上面的lambda是等价的，但是对于有捕获列表的lambda表达式应该怎么处理呢，例如：

    1
    2
    3
    4
    5
    6
    7
    void main()
    {
        int x = 10;
        int y = 20;
        auto f = [x,&y](int a ,int b){return a+b+x+y;}; //一个值捕获，一个引用捕获
        f(33,44);
    }

    如果转换成函数的形式：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    int x = 10;
    int y = 20;
    int f(int a,int b)
    {
      return a+bx+y;
    }
     
    void main()
    {
        f(33,44);
    }

    这是一种可行的方法，但是总不能把所有的捕获变量定义成全局变量吧。现在的关键问题是lambda的捕获表达式中的内容转换成函数不可行，C++11提供了bind函数来完成这样的操作。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #include <functional> //bind()
    #include <iostream>
    using namespace std;
    using namespace std::placeholders; // _1,_2所在的命名空间
    int f(int x,int y,int a,int b)
    {
      return a+b+x+y;
    }
     
    void main()
    {
      int x = 10;
      int y = 20;
     
      auto f_wrap = bind(f,x,y,_1,_2);
      cout<<f_wrap(33,44)<<endl; // _1,_2是占位符,表示调用f_wrap的时候_1是第一个参数,_2是第二个参数。最终会被替换成调用  f(10,20,33,44)
    }

    如果引用类型的捕获怎么做呢，看下面的例子，用lambda是这样的：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    #include <iostream>
    #include <functional>
    using namespace std;
    using namespace std::placeholders;
    void main()
    {
      int x = 10;
      ostream &o = cout;
      auto f =[&o](int a){o<<a<<endl;}; // 注意这里的输出对象是用的引用捕获
      f(x);
    }

    使用bind是这样的：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #include <iostream>
    #include <functional>
    using namespace std;
    using namespace std::placeholders;
    void f(ostream &o,int x)
    {
      o<<x<<endl;
    }
    int main()
    {
      int x = 10;
      auto f_wrap = bind(f,ref(cout),_1); //将变量的引用传递到bind中是个问题，为此C++11提供了ref()函数用于获得引用
      f_wrap(x);
      return 0 ;
    }

    6. 智能指针share_ptr,unique_ptr

    C++11中引入了几种智能指针，智能指针能够自动释放所指向的对象，其中shared_ptr允许多个指针指向同一个对象，unique_ptr则独占所指向的对象，我们主要说明shared_ptr的使用。通过使用make_shared<type>()函数产生智能指针对象。

    1
    2
    shared_ptr<int> p = make_shared<int>(40); // p指向一个值为40的int对象
    shared_ptr<string> p2 = make_shared<string>(10,'c'); //指向值为'cccccccccc'的string对象

    make_shared<type>()函数中传递的值要与对应的type的构造函数相匹配，实际上应该就是直接调用的对应type的构造函数。

    我们可以使用new初始化的指针来初始化智能指针：

    1
    2
    share_ptr<int> p (new int(40));
    p.get(); // 使用share_ptr<type>的get()函数来获得其关联的原始指针。

    shared_ptr对象在离开其作用域(例如一个函数体)，会自动释放其关联的指针指向的动态内存，就像局部变量那样。另外多个shared_ptr可以指向一个对象，当最后一个shared_ptr对象销毁的时候才会销毁其关联的那个对象的动态内存。这里使用了引用记数。

    7. 右值引用与move调用,移动构造函数

    为了支持移动操作，C++11中使用了一种称为右值引用的类型。移动操作是什么呢，一般情况下我们将一个对象赋值给另一个对象的时候会调用对象到拷贝构造函数或者拷贝赋值运算符。而移动构造函数和移动赋值运算符则用来将数据从一个对象移动到另一个对象。在很多情况下对象拷贝之后需要被销毁，此时使用移动操作会大幅提高性能。右值引用被使用之后，其关联的对象会被销毁。右值引用使用两个&&表示，例如 int && 表示右值引用，而int &则是左值。通过C++11标准库提供的函数 std::move()可以得到某一对象的右值引用。

    1
    2
    3
    4
    5
    TestClass::TestClass(TestClass &&t) noexcept //移动构造函数不应该抛出任何异常
    :x(t.x),y(t.y),z(t.z),p(t.p)
    {
      t.p=nullptr; // 实现移动操作之后需要保证被移动的对象的析构是安全的，所以源对象的指针成员置为空，随后t的析构函数将会被自动调用，t被销毁。
    }

    8. function

    C++11中提供了名为function的标准库类型，定义在头文件<functional>中，该类型用来存储一个可调用的对象，统一了所有可以像函数一样调用的调用形式，例如：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    #include <functional>
    #include <iostream>
    using namespace std;
     
    int add(int x,int y)
    {
        return x+y;
    }
     
    class Add
    {
        public:
            int operator()(int x,int y)
            {
                return x+y;
            }
    };
     
    void main()
    {
      //function模版的参数是函数调用形式,包括返回类型,以及参数列表个数和类型
        function<int(int,int)> f1 = add;  //函数指针
        function<int(int,int)> f2 = Add(); // 可调用类对象
        function<int(int,int)> f3 = [](int x,int y){return x+y;}; //lambda表达式
         
        cout<<f1(10,20)<<" "<<f2(30,40)<<" "<<f3(50,60)<<endl;
    }

    9. 其他新增类型(array,forward_list,bitset,regex)

    实际上C++11中除了一些语法特性新增之外，还增加了一些新的库。例如array相当于我们传统使用的定长数组，支持随机访问，不能添加删除元素，不可以像vector一样增长，使用array比传统数组更加安全。

    forward_list是C++11中增加的单向链表

    regex则是C++11中新增的正则表达式库

    10. 总结

    C++11中增加了一些库，库本身的使用不做过多介绍，可以参考C++标准库/STL源码剖析，这都是用单独的大部头书籍讲解的，有些特性和库是我感觉比较惊艳的，例如：

    auto 定义：可以让编译器自动推算定义的变量类型，而不需要写长长的一串类型，特别是在含有迭代器的类型上。
    decltype ：可以根据已知的变量来定义一个跟该变量一样的类型。
    lambda：个人认为这是C++11中增加的最惊艳的特性之一，对应的还有bind()函数，其实这些内容是从Boost中来的。
    智能指针：shared_ptr 虽然在以前的C++中有类似auto_ptr的智能指针，但是auto_ptr有一些缺陷并不算很好用。
    function类型：标准库的function类型定义了一种可调用对象，该类型统一了所有可以当作函数一样调用的调用形式，例如lambda，函数指针，重载了函数调用运算符()的类对象等，该特性也是参考了Boost库。
    regex库：C++11中总算有了方便的regex可以使用了。
  • 相关阅读:
    谁来催生国产中高档数控系统市场
    对于HBase的MapReduce性能提升方案之BulkLoad
    数据挖掘十大经典算法(9) 朴素贝叶斯分类器 Naive Bayes
    遇见程序猿男朋友
    理解class.forName()
    正则表达式
    java实现第七届蓝桥杯棋子换位
    java实现第七届蓝桥杯机器人塔
    java实现第七届蓝桥杯机器人塔
    java实现第七届蓝桥杯凑平方数
  • 原文地址：https://www.cnblogs.com/lenmom/p/9082214.html
Copyright © 2020-2023  润新知