C++11 相关小结

文档相关

首先，wiki是最全面的：https://en.wikipedia.org/wiki/C%2B%2B11，这是C++完整的新功能，个人使用的编译器可能不完整支持，可以看这个编译器+版本对C++1X的支持情况：http://en.cppreference.com/w/cpp/compiler_support 。

     然后，看英文不够快，找一篇看起来比较全的中文总结（不全，还是要看wiki）：http://www.cnblogs.com/pzhfei/archive/2013/03/02/CPP_new_feature.html。

新特性简介

C++11之前被称为C++0x，因为原本计划在2010年发布，所以之前一些编译器使用C++11的编译参数是：-std=c++0x，后面使用：-std=c++11。C++11 设计的核心是：少改动语言，多改动基础库。

改动涉及到这几点：支持多线程编程（增加了thread库）、加强泛型编程（增加了hash容器、任意多个元素的tuple、bind函数、lambda函数）、统一初始化（以花括号调用构造函数）、性能（右值引用和move），其它stl库（正则表达式、原子操作库），另外还有一些语法糖的支持，如：default、delete定义（可以在派生类中delete掉基类的public函数），裸字符串的定义、类非静态成员变量直接赋值、nullptr、支持连续两个右尖括号、后置返回类型、Range-based的for循环、构造函数可以调用另一个构造函数、override关键字用于发现虚函数的覆盖错误、string literal.......

部分常用新特性\库

之前，我想初始化一个放着map对象的容器，需要这样子：

std::vector<std::map<std::string, std::string> > a;
std::map<std::string, std::string> tmp;
tmp.insert(std::make_pair("1", "2"));
a.push_back(tmp);

现在，我可以直接用大括号：

std::vector<std::map<std::string, std::string>> a{ { { "1", "2" } } }

注： 部分统一初始化要到gcc4.7之后才支持。

函数绑定和lambda

函数绑定是基础库支持的，把一个函数转换为一个对象，在异步编程上用的很多（回调函数bind成一个对象，然后把对象交给异步工作完成的通知者，由它触发异步回调调用）。

lambda语法，则可以跟标准库的算法配合使用，或者跟bind一起用在异步编程上。

eg:bind

class Work {
public:
 void do_work() {
    std::cout << "do work" << std::endl;
  }
};
int main() {
    Work work;
    auto bar = std::bind(&Work::do_work, &work);
    bar();
}

清除字符串中的'a'字符：

std::string tmp = "abcdefgdaaa";
tmp.erase(std::remove_if(tmp.begin(), tmp.end(), [](char x) {
        return x == 'a';
    }), tmp.end());
std::cout << tmp << std::endl;

lambda语法：

利用Lambda表达式，可以方便的定义和创建匿名函数

Lambda表达式完整的声明格式如下：

[capture list] (params list) mutable exception-> return type { function body }

各项具体含义如下

1. capture list：捕获外部变量列表
2. params list：形参列表
3. mutable指示符：用来说用是否可以修改捕获的变量
4. exception：异常设定
5. return type：返回类型
6. function body：函数体

此外，我们还可以省略其中的某些成分来声明“不完整”的Lambda表达式，常见的有以下几种：

序号	格式
1	[capture list] (params list) -> return type {function body}
2	[capture list] (params list) {function body}
3	[capture list] {function body}

其中：

• 格式1声明了const类型的表达式，这种类型的表达式不能修改捕获列表中的值。
• 格式2省略了返回值类型，但编译器可以根据以下规则推断出Lambda表达式的返回类型： （1）：如果function body中存在return语句，则该Lambda表达式的返回类型由return语句的返回类型确定； （2）：如果function body中没有return语句，则返回值为void类型。

• 格式3中省略了参数列表，类似普通函数中的无参函数。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

bool cmp(int a, int b)
{
    return  a < b;
}

int main()
{
    vector<int> myvec{ 3, 2, 5, 7, 3, 2 };
    vector<int> lbvec(myvec);

    sort(myvec.begin(), myvec.end(), cmp); // 旧式做法
    cout << "predicate function:" << endl;
    for (int it : myvec)
        cout << it << ' ';
    cout << endl;

    sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });   // Lambda表达式
    cout << "lambda expression:" << endl;
    for (int it : lbvec)
        cout << it << ' ';
}

在C++11之前，我们使用STL的sort函数，需要提供一个谓词函数。如果使用C++11的Lambda表达式，我们只需要传入一个匿名函数即可，方便简洁，而且代码的可读性也比旧式的做法好多了

注：lambda需要gcc4.5之后才支持

 

直接给类成员变量设置默认值

class A {
public:
    A () {}
    explicit A(int new_value) : value(new_value) {}

    int get() {
        return value;
    }
private:
    int value = 5; // 支持直接写默认值
};

至少需要gcc4.7

新增tuple类型

tuple类型在传输多种类型组成的数据时，可以省去定义struct，而且可以有任意多的成员

std::tuple<std::string, std::string, std::string, int, int> record = std::make_tuple("a", "b", "c", 100, 200);
std::cout << std::get<0>(record) << std::endl;
std::cout << std::get<4>(record) << std::endl;

 

新增hash表

std::unordered_set

std::unordered_multiset

std::unordered_map

std::unordered_multimap

查找性能比set、map的要快。

新增多线程支持

std::thread

std::async

std::promise，std::future，

要特别说明下promise、future的概念：

“主线程创建一个promise，将与promise关联的future交给新的线程，新线程等待从promise获取数据，主线程通过promise向期望设置值，新线程收到通知继续往下走。”

这说明，promise/future是用于异步编程时，线程之间的同步的，有点像多线程编程下的event通知。

#include <iostream>
#include <functional>
#include <thread>
#include <future>
void show(std::future<int>& fut) {
    std::cout << "work thread：" << std::this_thread::get_id() << std::endl;
    int x = fut.get(); // 等待获取到结果
    std::cout << x << std::endl;
}
int main(){
    std::cout << "main thread：" << std::this_thread::get_id() << std::endl;
    std::promise<int> promise;
    std::future<int> future = promise.get_future();
    std::thread work_thread(show, std::ref(future));
    std::this_thread::sleep_for(std::chrono::seconds(3));
    promise.set_value(10);
    work_thread.join();
    return 0;
}

扩展说明： 从上面的例子可以看到，标准库的promise/future不支持设置回调函数，需要自己通过get函数等待，这是异步调用者（主线程）主动的在等待通知

 

智能指针

1.智能指针的作用

  C++程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。程序员自己管理堆内存可以提高了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常时内存泄露等问题等，使用智能指针能更好的管理堆内存。

详见智能指针的原理及作用

理解智能指针需要从下面三个层次：

1. 从较浅的层面看，智能指针是利用了一种叫做RAII（资源获取即初始化）的技术对普通的指针进行封装，这使得智能指针实质是一个对象，行为表现的却像一个指针。
2. 智能指针的作用是防止忘记调用delete释放内存和程序异常的进入catch块忘记释放内存。另外指针的释放时机也是非常有考究的，多次释放同一个指针会造成程序崩溃，这些都可以通过智能指针来解决。
3. 智能指针还有一个作用是把值语义转换成引用语义。

2.智能指针的使用

智能指针在C++11版本之后提供，包含在头文件<memory>中，shared_ptr、unique_ptr、weak_ptr

2.1shared_ptr的使用

shared_ptr多个指针指向相同的对象。shared_ptr使用引用计数，每一个shared_ptr的拷贝都指向相同的内存。每使用他一次，内部的引用计数加1，每析构一次，内部的引用计数减1，减为0时，自动删除所指向的堆内存。shared_ptr内部的引用计数是线程安全的，但是对象的读取需要加锁。

• 初始化。智能指针是个模板类，可以指定类型，传入指针通过构造函数初始化。也可以使用make_shared函数初始化。不能将指针直接赋值给一个智能指针，一个是类，一个是指针。例如std::shared_ptr<int> p4 = new int(1);的写法是错误的
• 拷贝和赋值。拷贝使得对象的引用计数增加1，赋值使得原对象引用计数减1，当计数为0时，自动释放内存。后来指向的对象引用计数加1，指向后来的对象。
• get函数获取原始指针
• 注意不要用一个原始指针初始化多个shared_ptr，否则会造成二次释放同一内存
• 注意避免循环引用，shared_ptr的一个最大的陷阱是循环引用，循环，循环引用会导致堆内存无法正确释放，导致内存泄漏。循环引用在weak_ptr中介绍。

#include <iostream>
#include <memory>

int main() {
    {
        int a = 10;
        std::shared_ptr<int> ptra = std::make_shared<int>(a);
        std::shared_ptr<int> ptra2(ptra); //copy
        std::cout << ptra.use_count() << std::endl;

        int b = 20;
        int *pb = &a;
        //std::shared_ptr<int> ptrb = pb;  //error
        std::shared_ptr<int> ptrb = std::make_shared<int>(b);
        ptra2 = ptrb; //assign
        pb = ptrb.get(); //获取原始指针

        std::cout << ptra.use_count() << std::endl;
        std::cout << ptrb.use_count() << std::endl;
    }
}

2.2 unique_ptr的使用

　　unique_ptr“唯一”拥有其所指对象，同一时刻只能有一个unique_ptr指向给定对象（通过禁止拷贝语义、只有移动语义来实现）。相比与原始指针unique_ptr用于其RAII的特性，使得在出现异常的情况下，动态资源能得到释放。unique_ptr指针本身的生命周期：从unique_ptr指针创建时开始，直到离开作用域。离开作用域时，若其指向对象，则将其所指对象销毁(默认使用delete操作符，用户可指定其他操作)。unique_ptr指针与其所指对象的关系：在智能指针生命周期内，可以改变智能指针所指对象，如创建智能指针时通过构造函数指定、通过reset方法重新指定、通过release方法释放所有权、通过移动语义转移所有权。

#include <iostream>
#include <memory>

int main() {
    {
        std::unique_ptr<int> uptr(new int(10));  //绑定动态对象
        //std::unique_ptr<int> uptr2 = uptr;  //不能賦值
        //std::unique_ptr<int> uptr2(uptr);  //不能拷貝
        std::unique_ptr<int> uptr2 = std::move(uptr); //轉換所有權
        uptr2.release(); //释放所有权
    }
    //超過uptr的作用域，內存釋放
}

2.3 weak_ptr的使用

　　weak_ptr是为了配合shared_ptr而引入的一种智能指针，因为它不具有普通指针的行为，没有重载operator*和->,它的最大作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。weak_ptr可以从一个shared_ptr或者另一个weak_ptr对象构造，获得资源的观测权。但weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。使用weak_ptr的成员函数use_count()可以观测资源的引用计数，另一个成员函数expired()的功能等价于use_count()==0,但更快，表示被观测的资源(也就是shared_ptr的管理的资源)已经不复存在。weak_ptr可以使用一个非常重要的成员函数lock()从被观测的shared_ptr获得一个可用的shared_ptr对象， 从而操作资源。但当expired()==true的时候，lock()函数将返回一个存储空指针的shared_ptr。

#include <iostream>
#include <memory>

int main() {
    {
        std::shared_ptr<int> sh_ptr = std::make_shared<int>(10);
        std::cout << sh_ptr.use_count() << std::endl;

        std::weak_ptr<int> wp(sh_ptr);
        std::cout << wp.use_count() << std::endl;

        if(!wp.expired()){
            std::shared_ptr<int> sh_ptr2 = wp.lock(); //get another shared_ptr
            *sh_ptr = 100;
            std::cout << wp.use_count() << std::endl;
        }
    }
    //delete memory
}

 

 

其他

（1）可以定义一个无需转义的字符串，如：std::string b = R"x(c:\abc)" yy l)x";

其中x(是一个标识符，x可以任意，最长16个字符。

注意：Raw string literals至少需要gcc4.4

参考：http://en.cppreference.com/w/cpp/language/string_literal

（2）正则表达式库

（3）构造函数委托

（4）std::shared_ptr 智能指针

（5）railing-return-type 后置返回类型

 

const用法

当const在函数名前面的时候修饰的是函数返回值，在函数名后面表示是常成员函数，该函数不能修改对象内的任何成员，只能发生读操作，不能发生写操作。

原理：

我们都知道在调用成员函数的时候编译器会将对象自身的地址作为隐藏参数传递给函数，在const成员函数中，既不能改变this所指向的对象，也不能改变this所保存的地址，this的类型是一个指向const类型对象的const指针。

一个函数名字后有const，这个函数必定是成员函数，也就是说普通函数后面不能有const修饰，如：int print( ) const {.......} 这个函数必定为成员函数，即在类里面定义的函数。

    在一个类里定义了一个const成员函数后，则此函数不能修改类中的成员变量，如果定义了一个类的const对象（非const对象可以调用const成员函数和非const成员函数 )，它只能调用类中的const成员函数，如：

class text{

        public:

               void print_const(void) const   { cout<<"hello"<<endl;}          //有const修饰

              void print(void) {cout<<"hello"<<endl;}            //没有const修饰

             void getk(void)  const  {k=5; }          //错误，有const修饰，不能修改k的值，

      private:

             int k;

};

const text a;

int main()

{

            a.print();           //错误，const对象只能调用

           a.printf_const();   //正确

}

eg：void print() const {}  和 void print() {}   是重载函数，假如对象为const，则调用void print () const成员函数，如果为非const，则调用void print() ；

class text{
public:
 void print(void) const {cout<<"hello_const"<<endl;}
 void print(void) {cout<<"hello"<<endl;}

};

const text a;      
int main()
{
 a.print();    //屏幕输出 hello_const  假如对象a 定义为 text a,则输出 hello
 return 0;
}

类模板

声明类模板时要增加一行
    template <class 类型参数名>
template意思是“模板”，是声明类模板时必须写的关键字。

eg:

声明一个类模板，利用它分别实现两个整数、浮点数和字符的比较，求出大数和小数。

 
#include <iostream>
using namespace std;
template <class numtype>
//定义类模板
class Compare
{
   public :
   Compare(numtype a,numtype b)
   {x=a;y=b;}
   numtype max( )
   {return (x>y)?x:y;}
   numtype min( )
   {return (x<y)?x:y;}
   private :
   numtype x,y;
};
int main( )
{
   Compare<int > cmp1(3,7);  //定义对象cmp1，用于两个整数的比较
   cout<<cmp1.max( )<<" is the Maximum of two integer numbers."<<endl;
   cout<<cmp1.min( )<<" is the Minimum of two integer numbers."<<endl<<endl;
   Compare<float > cmp2(45.78,93.6);  //定义对象cmp2，用于两个浮点数的比较
   cout<<cmp2.max( )<<" is the Maximum of two float numbers."<<endl;
   cout<<cmp2.min( )<<" is the Minimum of two float numbers."<<endl<<endl;
   Compare<char> cmp3(′a′,′A′);  //定义对象cmp3，用于两个字符的比较
   cout<<cmp3.max( )<<" is the Maximum of two characters."<<endl;
   cout<<cmp3.min( )<<" is the Minimum of two characters."<<endl;
   return 0;
}

可以这样声明和使用类模板：
1) 先写出一个实际的类。由于其语义明确，含义清楚，一般不会出错。

2) 将此类中准备改变的类型名(如int要改变为float或char)改用一个自己指定的虚拟类型名(如上例中的numtype)。

3) 在类声明前面加入一行，格式为：
    template <class 虚拟类型参数>
如：
    template <class numtype> //注意本行末尾无分号
    class Compare
    {…}; //类体

4) 用类模板定义对象时用以下形式：
    类模板名<实际类型名> 对象名;
    类模板名<实际类型名> 对象名(实参表列);
如：
    Compare<int> cmp;
    Compare<int> cmp(3,7);

5) 如果在类模板外定义成员函数，应写成类模板形式：
   template <class 虚拟类型参数>
   函数类型 类模板名<虚拟类型参数>::成员函数名(函数形参表列) {…}

 

参考文献

1.https://www.cnblogs.com/cswuyg/p/6220671.html

2.https://www.cnblogs.com/DswCnblog/p/5629165.html