ykun089的博客

shared_from_this 要求对象在创建之初就是通过 make_shared 或者 std::shared_ptr 的构造来完成的，不能如下几种情况：1） heap new 出来且没使用 make_shared 或者 std::shared_ptr 新创建一个 shared_ptr 实例；2）不能是 unique_ptr 实例，即便是通过 release() 转换成 裸指针都不行，会导致奔溃和卡住，这一点很奇怪，感觉像bug，这里极其容易犯错；

那么多次使用 shared_from_this 也是创建了多个 shared_ptr， 是否会导致double free呢？，因为shared_from_this 的内部是 weak_ptr 实现，所以不会导致 double free。

shared_ptr 可以用来自动管理实例(内存) 的生命周期，但是如果对同一个实例(内存) 创建多个 shared_ptr 则可能引起 double free 的问题。

有两种对象构造方法，一是在指定内存上构造对象，另一个是先构造一个临时对象，然后把对象拷贝到指定内存上。

我们再使用 std::get 的时候发现其模板并不是一个类型，而是一个整数值，用来标识从某个位置获取值，比如 std::pair 类型的数据 tmppair，那么就可以通过 std::get(tmppair)来获取key的值，通过 std::get(tmppair)来获取value的值。这就是非类型模板参数的一个用例。非类型模板参数允许我们使用值作为模板类型，这个值可以是整数，引用，指针等等。既然是使用值(左值/右值) 作为模板的某个参数，那么为什么不把这个值直接函数入参传递给函数呢？

C++ library headers <algorithm> <iomanip> <list> <ostream> <streambuf> <bitset> <ios> <locale> <queue> <string> <complex> <iosfwd> <map> &l

c++17里引入了std::any类型，这个类型类似于union类型，但是比union功能多且能容纳所有类型(内置类型/自定义类型)，同时提供 type 方法用于获取一个 type_info 实例，进而用于准确判断入参的准确类型。

头文件：#include typeindex库 包含两个类 std::type_info 和 std::type_index。

type_traits 又叫类型萃取，是一个在编译阶段用于进行类型判断/类型变更的库，在c++11中引入。因为其工作阶段是在编译阶段，因此被大量应用在模板编程中，同时也可以结合 constexpr 这种在编译阶段就进行计算的语句进行编译阶段的运算。

c++98 提出了匿名namesapce ，所有定义在匿名namespace中的变量都具备内部连接属性，所以可以把续要定义的值放在匿名namespace里，再把相关代码放入源文件里，这样做的缺点在于无法在h/hpp头文件中访问到这些变量，因此头文件无法获知源文件里的值。//1.hpp//错误//由于无法访问cpp中的符号，所以这里没法定义arr的尺寸。//1.cpp。

C++ 17开始，引入了两个新的同步组件， shared_mutex 和 shared_lock ，这两个组件的一个典型使用案例就是实现读写锁。

c++ 11 引入了 chrono 用以处理时间/时区相关的问题。

当使用 std::function 保存 std::binder 的返回值时，需要注意所有被 placeholder 占用的参数位置都不应该再出现再 std::function 的模板列表里。

modern c++ 的一个重要特性就是 函数对象/可调用对象 式编程，代表性的用法为 boost::bind，std::bind，lambda。这些组件的功能是把一段代码封装程一个可以可调用对象，这个对象可以存在于堆中，也可以存在于栈中，本质上是创建一个临时类，再把传递给可调用对象的局部变量作为类的成员变量存储起来，这里的存储可以是值存储，也可以是引用或者地址，因此需要考虑生命周期的问题。当把可调用对象作为对象来使用，比如入参，全局变量，静态全局变量等等。可以让其存在于堆或者栈里。

Metaprogramming library (since C++11) - cppreference.comhttps://en.cppreference.com/w/cpp/meta

如果不涉及函数式编程，那么基本上不需要使用到 std::ref ， 这个功能式是。，不过如果使用指针则同样不需要 std::ref，如果不用指针则大概率会需要。用来解决函数式编程时入参。

#include <iostream>#include <functional>using namespace std;void(*p)(void);int TestFunc(){ auto func = []()->void { cout << "123" << endl; }; p = func; return 0;}int main(){ TestFunc(); p(); return 0

Windows 下 有CreateSemaphore 来创建信号量，c++ 11 没有实现信号量，可以用条件变量来模拟信号量： class CSemaphore { public: CSemaphore(); ~CSemaphore(); void semaphoreP(unsigned int timeout = 0) { std::unique_lock<std::mutex&.

tuple 几乎允许所有常用的构造方式：赋值、拷贝、移动，完全可以当做 基本类型使用，不要有任何心理负担。make_tuple 不需要指定模板类型，会自动根据入参返回相应的tuple，可以选择使用tuple的构造函数创建tuple对象，也可以使用make_tuple进行不要指定模板类型的tuple对象构建。看具体的使用场景。...

使用条件变量可以模拟 Event：#ifdef WIN32 HANDLE hEventHandle; //事件句柄#elif LINUX std::mutex hEventHandleLock;//配合条件变量需要使用的锁 std::condition_variable hEventHandle;//条件变量#endif#ifdef WIN32 if (hEventHandle) { ::SetEvent(hEventHandle); } el

前言https://blog.youkuaiyun.com/ykun089/article/details/115349993中描述的是 serilization 模式的数据结构，其锁的粒度很大，虽然说是多线程安全的，但是无法进行并发（concurrency）访问，从而导致同一时刻只能有一个线程在操作数据结构。如果想实现并发访问，一种是使用低粒度锁的数据结构，另一种就是无锁的数据结构设计。其实低粒度锁属于 “伪并发”，它在是否能真正设计成并发需要视应用场景而定。虽然都有锁，粗粒度锁就是串行化访问，低粒度锁.

https://blog.youkuaiyun.com/ykun089/article/details/114626026 中介绍了可能导致死锁的几个场景，场景二和场景三的处理都很简单，但是对于场景一则需要使用一些手段处理。手段一：使用 std::lock 统一对多个锁加锁如果我们的加锁动作不是分散的，而是一开始就要对多个锁 同时加锁(这里的同时只是说步骤上看是集中进行，而不是说 100% 同时)。那么可以通过 std::lock 来进行这个动作，此组件可以保证100%不会出现死锁，而且传入的锁都会被...

std::memory_order - cppreference.commemory ordering 又叫内存序，这个翻译其实不直观，更加具体应该叫做 cpu 访问内存的顺序(FIX Me If wrong)。这个概念的引入是为了解决 “多线程读写多变量” 场景下的乱序问题。如果针对多线程读写多变量时使用粒度较粗的锁，那么在不考虑效率的前提下，可以不用考虑memory ordering问题，比如下面的代码已经通过加锁解决了同步问题：上面的问题是锁的粒度较大，如果想要减小锁的粒度，或者直接不加锁还能保

weak_ptr 是给 shared_ptr做补充的，把weak_ptr增加到shared_ptr指向的对象上，不会增加计数，单当shared_ptr全部释放完以后，weak_ptr指向的内容也将不存在。可以这样理解，make_shared 相当于 new ，尖括号指定需要分配内存的类型名，小括号指定作为拷贝构造传递给类型名的值，如果不指定，那么使用类型的默认构造。上面提到了智能指针的使用方法，通过make_shared来分配内存，但是如果想使用new来分配内存，然后交由智能指针管理，该如何操作？

atomic库的底层也是有锁的，仅 std::atomic_flag 底层是不需要锁来辅助完成 atomic 操作，其他的类型包括 atomic<int> 、atomic<bool> 。。。 等在内部基本都是通过锁的机制来完成 atomic。不过具体情况要视编译器和操作系统而定，至少c++ 11标准中对于这块的要求是 expected ，而不是 required。...

前面讨论了 std::weak_ptr ， 这里说一下使用 weak_ptr 需要注意的地方：不正确地使用weak_ptr可能会导致奔溃。因为weak_ptr的lock()函数是noexcept的：所以如果不加判断就直接 解引用lock的返回值，可能会导致崩溃：......

引言c++ 11开始引入了对个可调用对象，比如 lambda，std::function，std::bind ，这些手段的目的只有一个，就是用来创建可调用对象，区别在于各自的适用场景不同，lambda用来创建一个临时可掉用对象，std::bind是一个函数，用来调整已有可调用对象的传参方式，并返回一个可调用对象。std::function 是一个模板函数，可以用来包裹函数、成员函数、lambda或者可调用对象。可以把std::function类比为一个函数指针，只不过这是一个可以实例化的指针。

接：[modern c++] std::function的使用_ykun089的博客-优快云博客

定性描述：std::future 可以用来获取所有异步操作的结果，换句话说，modern c++ 中所有异步操作的结果都保存在 std::future 中。

描述：如果使用new 创建数组，那么请使用deleye[] 来释放数组，否则当数组元素不是基础类型时，会无法触发每个数组元素的析构，又如果这些数组元素会在自己的析构函数中“手动释放"动态申请的内存，那么这就会导致这些动态申请的内存无法被释放，从而产生内存泄露。char*p = new char[10]; //使用 new 申请 10个char 的数组delete p; //不会内存泄露,但是不推荐,delete[] p; //推

前言：std::bind 用来生成一个可调用对象，其使用的入参是一个可调用对象和一系列占位符。例子：#include <iostream>#include <functional>using namespace std;int TestFunc(int a, char c, float f){ cout << a << endl; cout << c << endl; cout << f &

参考：std::async - cppreference.comhttps://en.cppreference.com/w/cpp/thread/async简介：c++11 提供了便捷的多线程运行库，比如std::thread ，std::future，std::condition_variable等等，std::async函数就是其中之一，其接受一个可执行对象，也接受一个参数入参(注意内存安全)，然后独立启动一个线程执行可执行对象，或者在调用std::async的线程中执行可执行对象。如果指定

参考：bind - C++ Referencebind完成了什么功能？bind使用传入的函数(普通函数，成员函数)创建一个callable对象，并作为返回值返回。bind是否必要？bind最早设计出来的目的可能是为了创建临时callable对象，这类似于lambda。此外，可以通过bind把成员函数导出为回调函数。貌似自从c++ 11的lambda出来以后bind的使用就变得比较少了。原型：simple(1) template <class Fn,

参考：https://blog.youkuaiyun.com/yand789/article/details/27324295compare_exchange_weak 的伪码逻辑：if *this == expected: *this = desired;else: expected = *this;这里涉及到 三个值：1）要检查的内存地址内的值 *this ；2）希望 *this 内应当是什么值 expected ； （对应compare）3...

https://blog.youkuaiyun.com/hyp1977/article/details/51784520

std::weak_ptrIt must be converted to std::shared_ptr in order to access the referenced object.std::weak_ptr is used to track the object, and it is converted to std::shared_ptr to assume temporary ownership.If the original std::shared_ptr is destroyed

C++ -Standardshttp://open-std.org/JTC1/SC22/WG21/docs/standards

TODO

单例模式分为懒汉和饿汉两种。饿汉式的写法比较固定也没有风险，懒汉式的写法比较多变且存在各种潜在的风险。

当我们希望某些代码只会被调用一次时，可以使用 std::call_once 来实现。