thefist的专栏

std::array 对象的大小是固定的，如果容器大小是固定的，那么可以优先考虑使用 std::array 容器。 另外由于 std::vector 是自动扩容的，当存入大量的数据后，并且对容器进行了删除操作， 容器并不会自动归还被删除元素相应的内存。// CPP program to demonstrate working of array#include <algorithm>#include <array>#include <iostream>#inc.

~weak_ptr() noexcept { this->_Decwref(); } weak_ptr& operator=(const weak_ptr& _Right) noexcept { weak_ptr(_Right).swap(*this); return *this; } template <class _Ty2> weak_ptr& operator=(...

1. 类定义// CLASS TEMPLATE weak_ptrtemplate <class _Ty>class weak_ptr : public _Ptr_base<_Ty> { // class for pointer to reference counted resourcepublic: constexpr weak_ptr() noexcept {} weak_ptr(const weak_ptr& _Other) noexcept {

1. 用于避免shared_ptr相互指向产生的环形结构，造成的内存泄漏：“死锁”内存都没有释放。struct A;struct B;struct A { std::shared_ptr<B> pointer; ~A() { std::cout << "A 被销毁" << std::endl; }};struct B { std::shared_ptr<A> pointer; ~B() {

有一个_Compressed_pair成员，类似于pair<key,value>队// CLASS TEMPLATE unique_ptr SCALARtemplate <class _Ty, class _Dx /* = default_delete<_Ty> */>class unique_ptr { // non-copyable pointer to an objectpublic: using pointer = typenam.

template <class _Ty>class shared_ptr : public _Ptr_base<_Ty> { // class for reference counted resource managementprivate: constexpr shared_ptr() noexcept = default; constexpr shared_ptr(nullptr_t) noexcept {} // construct empty shared_

1. 使用场景shared_ptr p(u) p从unique_ptr u中接管了对象的所有权；将u置为空 1.1 函数定义template <class _Ux, class _Dx, enable_if_t<conjunction_v<_SP_pointer_compatible<_Ux, _Ty>, is_convertible<typename unique_ptr<_Ux, _Dx>::point

1. 构造函数shared_ptr p(u) p从unique_ptr u中接管了对象的所有权；将u置为空template <class _Ux, class _Dx, enable_if_t<conjunction_v<_SP_pointer_compatible<_Ux, _Ty>, is_convertible<typename unique_ptr<_Ux, _Dx>::poin

1. 几种构造函数shared_ptr p(q) p管理内置指针q所指的对象；q必须指向new分配的内存，且能够转换为T类型shared_ptr p(q,d) p接管了内置指针q所指向的对象的所有权。q必须能转换为T类型。p将使用可调用对象d来代替deleteshared_ptr p(p2,d) p是shared_ptr p2的拷贝,唯一的区别是p将使用可调用对象d来代替delete1.1 如果参数是shared_ptr引用，那么调用底层的construct函数，计算器加1，否则如果是&&

template <class _Ty>class _Ptr_base { // base class for shared_ptr and weak_ptrpublic: using element_type = remove_extent_t<_Ty>; _NODISCARD long use_count() const noexcept { return _Rep ? _Rep->_Use_count() : 0; }

1. 创建计数器_Ref_count类template <class _Ux,enable_if_t<conjunction_v<conditional_t<is_array_v<_Ty>, _Can_array_delete<_Ux>, _Can_scalar_delete<_Ux>>, _SP_convertible<_Ux, _Ty>>, int> = 0>explicit shared_p

. 保证线程安全. 析构时如果计数器为0，删除自身// CLASS _Ref_count_baseclass __declspec(novtable) _Ref_count_base { // common code for reference countingprivate: _Atomic_counter_t _Uses = 1; _Atomic_counter_t _Weaks = 1;protected: constexpr _Ref_count_base()

template <class _Ty1, class _Ty2, bool = is_empty_v<_Ty1> && !is_final_v<_Ty1>>class _Compressed_pair final : private _Ty1 { // store a pair of values, deriving from empty firstpublic: _Ty2 _Myval2; using _Mybase = _Ty

1. 使用=default来要求编译器生成一个默认构造函数struct Point{ Point() = default;//不用像下面的构造函数一样要一一对成员变量赋值 Point(int _x, int _y):x(_x),y(_y){} int x=0; int y=0;};eg.// use of defaulted functions#include <iostream>using namespace std;class A {p.

1. 场景一个给定操作需要两个或两个以上的互斥量时可能会出现。class LogFile{public: LogFile() { f.open("log.txt"); } void shared_print(string msg,int idx) { lock_guard<mutex> locker1(m1); lock_guard<mutex> locker2(m2); f << msg << ":" << idx

1. 使用场景：死锁MutexLock mutex; void foo() { mutex.lock(); // do something mutex.unlock(); } void bar() { mutex.lock(); // do something foo(); mutex.unlock(); } 1.1 解决方案#include <iostream>#in.

1. 可以在声明后的任意位置调用， 可以缩小锁的作用范围，提供更高的并发度#include <iostream>#include <mutex>#include <thread>int v = 1;void critical_section(int change_v) { static std::mutex mtx; std::unique_lock<std::mutex> lock(mtx); // 执行竞争操作

1. std::unique_lock与std::lock_guard类似。通过对lock和unlock进行一次薄的封装，都能实现自动加锁与解锁功能，但是std::unique_lock要比std::lock_guard更灵活，占用空间相对更大一点且相对更慢一点。1.1 主要成员函数unique_lock() noexcept;//不管理任何 Mutex 对象 explicit unique_lock(mutex_type& m);管理 Mutex 对象 m，并尝试调用 m.lock()

1. 使用场景mutex是不安全的，当一个线程在解锁之前异常退出了，那么其它被阻塞的线程就无法继续下去。2. lock_guard相对安全，它是基于作用域的，能够自解锁.当该对象创建时，它会像m.lock()一样获得互斥锁当生命周期结束时，它会自动析构(unlock)，不会因为某个线程异常退出而影响其他线程。int cnt = 20;std::mutex m;void t1(){ while (cnt > 0) { std::lock_gu

1. mutex是用来保证线程同步的，防止不同的线程同时操作同一个共享数据1.1 C++11四种互斥量std::mutex，最常用，普遍的互斥量（默认属性），独占式互斥量std::recursive_mutex ，允许同一线程使用recursive_mutext多次加锁，然后使用相同次数的解锁操作解锁（mutex多次加锁会造成死锁）std::timed_mutex，允许超时的独占式互斥量，在mutex上增加了时间的属性。增加了两个成员函数try_lock_for()，try_lock_u

1. 原子数据类型不会发生数据竞争，能直接用在多线程中而不必我们用户对其进行添加互斥资源锁的类型。从实现上来看，我们可以理解为这些原子类型内部自己加了锁。//c11.cpp#include <thread>#include <atomic>#include <stdio.h>#include <iostream>#include <list>std::atomic<bool> bIsReady(false);std::

1.1class id { native_handle_type _M_thread; public: id() noexcept : _M_thread() { } explicit id(native_handle_type __id) : _M_thread(__id) { } private: friend class thread; friend class hash<thread::i

1. 脱离主线程的绑定，主线程挂了，子线程不报错，子线程执行完自动退出。void pause_thread(int n) { std::this_thread::sleep_for (std::chrono::seconds(n)); std::cout << "pause of " << n << " seconds ended\n";}int test() { std::cout << "Spawning and det

1.1using namespace std; void fun1(int n) //初始化构造函数 { cout << "Thread " << n << " executing\n"; n += 10; this_thread::sleep_for(chrono::milliseconds(10)); }

1. thread类主要方法不支持 CopyConstructible or CopyAssignable,支持 MoveConstructible and MoveAssignable.构造函数默认构造函数：构造一个任何线程不执行的线程对象。thread() noexcept;初始化函数：template <class Fn, class… Args> explicit thread (Fn&& fn, Args&&… args);拷贝构造函

template< std::size_t I, class… Types >typename std::tuple_element<I, tuple<Types…> >::type& get( tuple<Types…>& t ) noexcept;(1)(since C++11)(constexpr since C++14)template< std::size_t I, class… Types...

1、下载boost库（本实例用的boost1.63）并解压2、进入boost库解码目录，打开VS2017开发人员命令提示符，命令行执行bootstrap.bat，生成b2或bjam可执行编译工具；3. 运行b2命令.–prefix指定路径. variant=debug|release决定编译用什么版本（Debug or Release）. link=static|shared决定使用静态库还是静态库注：/MT是 "multithread, static version ” 意思是多线程

1. class signal命名空间: boost::signals2::signalnamespace boost{ namespace signals2 { template<typename Signature,typename Combiner = optional_last_value<typename boost::function_traits<Signature>::result_type>, typename Group.

实际问题：书架上有很多书，现在要迭代每本书。client端：最终模式为：

#pragma once#include "stdio.h"#include <stdlib.h>#include <string.h>#include <string>using namespace std;class MyTestString{public: MyTestString() :pszData(nullptr),...