天天看点

C++11简单整理

C++11中 静态成员构造的时候线程安全的:static Database database;

1、

static_assert

静态断言发生在编译期,发现错误,(模板中使用较多,或者一些常量)

static_assert(sizeof(a) == sizeof(b), “parameters must have same width”)

2、

noexcept

修饰函数不抛出异常,编译器为析构函数默认是不抛出异常的

3、快速初始化成员变量:

使用=或{}

在类内除进行初始化

4、

final/override

final

修饰类为不可继承,修饰函数不可重写

override

修饰函数为重写函数(提醒作用)

default:

使用编译器提供的默认的构造函数

deleted:

删除编译器提供的函数

nullptr

:指针空值,消除字面常量0二义性、提升可读性健壮性

using

关键字:的能力包括了typedef的部分,

using uint=unsigned int;

别名

auto

:自动类型推倒

typeid(a).name():

返回a变量类型的名字

decltype()

推导返回类型,其成员不会继承const和volatile限制符

for(auto var:vectors)

范围for循环

constexpr

常量表达式、常量表达式函数、编译时常量,运行时常量

5、继承构造函数

using A::d();

委派构造函数:是在参数列表中执行

6、

右值引用

:消除临时对象销毁的效率

右值

:临时对象,函数返回值,运算表达式结果,字面值常量

将亡值

(被右值引用绑定的右值为将亡值)

右值引用意义

:对将亡值进行引用,实现移动语义

避免 先拷贝再废弃 替换成移动,所带来的性能浪费

左值和右值都是引用类型,都必须初始化,引用左值为别名,右值引用为匿名变量的别名

解决临时对象的资源浪费

可以通过move将左值抓话为右值,用于移动语义

7、完美转发:

forward<T>(t)

指在函数模板中,完全依照模板的参数类型将参数传递给函数模板中

调用的另外一个函数

8、强类型枚举:

enum class Type:char{red,green,};

:强作用域、转换限制、可以指定底层类型

9、

智能指针

:堆内存管理与回收

问题:野指针、重复释放、内存泄露

unique_ptr\shared_ptr\weak_ptr

来自动回收堆分配对象

unique_ptr<int> up1(new int(1))

;独占指针不允许赋值只能move

shared_ptr

有引用计数,当引用计数为0的时候释放内存

weak_ptr

可以指向shared_ptr指针指向的对象内存,确不拥有该内存

weakptr

用于解决循环引用问题

通过lock成员返回其指向内存的一个shared_ptr对象,对象内存无效时返回空指针

用来验证shared_ptr的有效性、和解决循环引用问题

垃圾回收方式:1、基于引用计数 2、基于跟踪处理的垃圾回收器
           

10、变长模板、模板参数可变、典型应用tuple

tuple<int,double,char>

11、并行编程库

thread

:可以不再是使用POSIX繁琐的库

原子操作:最小的且不可并行化的操作,多个线程对一个共享资源操作,

有且只有一个现成可以操作资源,其他线程阻塞

为了保证原子性,需要使用互斥量mutex进行对资源的锁定

为了防止线程间对数据的竞争,需要确保对数据的操作是原子性的

atomic模板类

std::atomic<T> t;

我们可以直接定义一个原子操作的数据

互斥量、条件变量、原子变量

异步操作:

future

:作为异步结果的传输通道,获取线程函数返回值(通过future状态获取操作结果)

promise

:用来包装一个值,将数据和future绑定起来,方便线程赋值

packaged_task

:用来包装一个可调用对象,将函数和future绑定起来,以便异步调用

线程异步操作函数

async

12、线程局部存储TLS:拥有线程生命期及线程可见性的变量

(例子error code是全局的,但是每个线程都会有errorcode)

int thread_local errCode;

线程模型

:线程会拥有自己的栈空间,但是堆空间和静态数据区是共享的

(全局、静态变量data\bss)

13、快速退出:

quick_exit at

terminate()

没有被捕捉的异常会导致该函数调用,然后调用abort()异常终止程序不

abort()

异常退出、不调用析构函数

exit()

正常退出、调用析构函数

14、

lambda

函数:匿名函数

[](int a,int b){return a+b}

15、unicode支持

char:UTF-8

char16_t:UTF-16

char32_t:UTF-32

常量字符串编码格式前缀:u8\u\U

char16_t utf16[]=u"hello";

char32_t utf32[]=U"hello eqyak";

16、原生字符串字面量:所见即所得,转义字符不起作用

R"(hello \n world)"

17、增加无序容器

unordered_set map multiset multimap

底层使用

hash_table

线程池

:预先创建一定数量的线程,当任务请求到来时从线程中

分配一个预先创建的任务去处理,完成后不会销毁

避免大量的创建和销毁消耗过多的系统资源

同步服务层,用来处理来自上层任务请求,将请求放入同步队列中

多个线程从队列当中取出任务并行处理

异步操作:

#include <iostream>
#include <future>
using namespace std ;

int func(int x) { return x + ; };

int main()
{
    //线程操作的返回值
    std::promise<int> pr;
    std::thread t([](std::promise<int>& p)
    {
        p.set_value_at_thread_exit();
    }, std::ref(pr));
    t.join();
    std::future<int> f = pr.get_future();
    auto r = f.get();
    cout << "r = " << r << endl;

    //异步操作的返回值
    std::packaged_task<int()> task([]() { return ; });
    std::thread(std::ref(task)).detach();
    std::future<int> f1 = task.get_future();
    auto r1 = f1.get();
    cout << "r1 = " << r1 << endl;

    //async
    auto a = std::async(std::launch::async, func, );
    cout << "func () a = " << a.get() << endl;

    auto ff = std::async(std::launch::async,
                         [](int a, int b)
                         {
                             std::this_thread::sleep_for(chrono::seconds());
                             return a + b;
                         }, , );
    cout << "async start" << endl;
    cout << "ff = " << ff.get() << endl;//阻塞
    cout << "async end" << endl;
    system("pause");
    return ;
}