nodejs 设计思想杂记四 异步控制流模式 parallelvar tasks = [...];var completed = 0;tasks.forEach(function(task) {task(function() {if(++completed === tasks.length) {finish();}});async的使用 async.series(tasks, [callback])func
nodejs 设计思想杂记 三 observer模式 观察者模式：一个对象，当其状态改变时能够通知一系列的观察者。EventEmitter看图说话使用方法：var EventEmitter = require('events').EventEmitter;var eeInstance = new EventEmitter();提供有几个接口：on(event, listener): 对event与linst
nodejs 单例模式实现 function Logger(name) {if(!(this instanceof Logger)) {return new Logger(name);}this.name = name;};
nodejs设计思想杂技二 callback 模式 回调。。。。与return回调函数如何替代return的功能？同步的函数function add(a, b) {return a + b;}异步的函数function add(a, b, callback) {callback(a + b);}同步的函数执行后return异步的函数执行完将结果放入callback中同步
nodejs 设计思想杂记一 reactor模式 开始正题，reactor 模式nodejs关于异步的本质，以及隐藏在此模式背后的故事。如单进程单线程的架构、非阻塞IO。最后看下整个nodejs平台。IO很慢，相比于CPU的处理速度来说，在非密集型计算的应用场景下，IO是一个拖慢速度的瓶颈。当然，现在正火的深度学习可以一次跑上几个月。。。。这种计算密集型的应用场景下除外。一个传统的阻塞型io的例子，线程池中每个线程处理
share_ptr的线程安全读写方式 class T { public: int get() { return t; } void set(int num) { t = num; } T():t(1) {}private: int t; };std::mutex g_mut;std::shared_ptr g_ptr;void func(const std::shared_ptr& pt) { std::coutge
aop之应用 时间记录器及日志 struct TimeElapsedAspect{ void Before(int i) { m_lastTime = m_t.elapsed(); } void After(int i) { std::cout << "time elapsed: " << m_t.elapsed() - m_lastTime << "ms" <<std::endl; }private:
c++ 面向切面变成 aop 通用模板 #ifndef AOP_h#define AOP_h#define HAS_MEMBER(member)\templatestruct has_member_##member\{\private:\ template static auto Check(int) -> decltype(std::declval().member(std::declval()...), std::tr
c++11 计时器 #pragma once#includeusing namespace std;using namespace std::chrono;class Timer{public: Timer() : m_begin(high_resolution_clock::now()) {} void reset() { m_begin = high_resolution_clock::now(
对象池 c++11 #ifndef COBJECTPOOL_H#define COBJECTPOOL_H#include #include #include #include const int maxObjectNum = 10;templateclass ObjectPool { template using Consturctor = std::function(Args...)>;pub
使用函数包装器的 通用泛化的命令类 //#ifndef COMMCOMMAND_H#define COMMCOMMAND_H#include#includetemplate class CommCommand{private: std::function m_f;public: //接受可调用对象的函数包装器 template::value>::type> void Wrap(F &&f, Args &
std::forward 完美转发 templateinline auto FuncWrapper(Function &&f, Args &&...args){ return f(std::forward(args)...);}void hello(){ std::cout << "hello" << std::endl;}void hello1(std::string x){ std::cout << x
c++ final关键字 final关键字来限制类不能被继承，或者虚函数不能被重写。class A final {virtual void hehe() final;};如此，class A不能被其他类集成，hehe（）函数也不能被重写
c++ weak_ptr weak_ptr是用来监视shared_ptr的，不会使引用计数增加。 std::shared_ptr t(new int(10)); std::weak_ptrwk(t); if(wk.expired()) std::cout<<"t is expired"<<std::endl; else std::cout
c++ tuple的基本操作 //create tuple std::tuple tp = std::make_tuple(2,2); int a,b; //get the value of tp std::tie(a,b) = tp; std::cout<<a+b<<std::endl; a = 0; //only get one value of tp std::tie(a,std::ignore) = t
c++ lambda表达式捕获变量参数 []不捕获任何变量[&]捕获外部作用域中所有变量，并作为引用在函数体重使用[=]捕获外部作用域中所有变量，并作为副本在函数体重使用[=，&foo]捕获外部作用域中所有变量，并作为副本在函数体重使用，对于foo按引用捕获[foo]当作副本捕获foo，不引入其他变量[this]捕获当前类中的this指针，让lambda表达式拥有和当前类成员函数同样的访问权限。如果已经使用了&或者=
c++ std::bind 基本用法 #include void hello(int a){std::cout<<a<<std::endl;}void call_when(int x,const std::function &f){if(x == 0) f(x);} auto pt = std::bind(hello,std::placeholders::_1); call_when(0,pt);
c++ std::function作为参数传入函数 #include void hello(int a){std::cout<<a<<std::endl;}void call_when(int x,const std::function &f){if(x == 0) f(x);} call_when(0,hello);需要头文件functional，在std::function作为参数使用时，必须加con
c++ 可调用对象 可调用对象分为如下几种：1 函数指针2 具有Operator（）成员函数的类对象3 可被转换为函数指针的类对象4 类成员函数指针函数指针即函数的名字，直接调用即可具有operator成员函数的类对象，如下例所示：class foo{public: void operator()(void) {}};调用时：foo f;f();类的函数指
关注
