学习笔记1

学习一门语言，理论的重要性是不言而喻的。你接触的知识面越广，了解（并非一定达到掌握）的知识越多，就会发现你的立足点已经在不知不觉中悄然升高了，视野也越来越广阔了。当你攻克一到多个优秀开源代码，这种感觉就更加深刻了。一款优秀的开源代码通常短小精悍，鲁棒性强，而且效率颇高。好多技巧的运用之美在你的理论知识积累到一定程度才会慢慢体会的到。比如c++语言，more effective c++中的条款1中就介绍到要吧c++语言看作是一个语言联邦:1、c 语言 2、object-oriented c++ 3、template c++(generic programming) 4、STL。当你伴着这些知识以及设计模式功底去反复阅读优秀的开源代码，你对代码的设计之美便会有越来越深的体会，不知不觉中有醍醐灌顶之感。

个人感觉书上的代码如同理论一样，给人的感觉十分泛泛，若没有优秀工业级代码的熏陶，你是很难感觉到质的飞跃。

本人计划阅读的优秀开源代码：1.protoubuf 2.poco 3.STL源码 4.muduo

/src/google/protobuf/stubs

1.common.h/common.cc

//-------------------------------------------------------------------------------------------------

禁用拷贝和赋值函数。在effective c++中就有此条款06：若不想使用c++默认生成的函数（4个）就明确拒绝。类似的实现如boost库中的noncopyable类的实现。

//-------------------------------------------------------------------------------------------------

类似于BOOST_STATIC_ASSERT,二者区别于assert(编译期&&运行期)

//-------------------------------------------------------------------------------------------------

有关Scoped_ptr Scoped_arry类的封装。可试着实现shared_ptr、weak_ptr、unique_ptr

//-------------------------------------------------------------------------------------------------

closure的封装，类似于boost function/bind的封装。支持1-3个参数，可为自由函数和类成员函数。可用其实现简单的thread封包函数。

//--------------------------------------------------------------------------------------------------

对Mutex的RAII封包，类似可见muduo中的mutex封包。
//--------------------------------------------------------------------------------------------------
常用宏定义

//-------------------------------------------------------------------------------------------------

#include <iostream>
#include <semaphore h="">
#include <pthread h="">
#include <string h="">
using namespace std;

#undef DISALLOW_EVIL_CONSTRUCTORS
#define DISALLOW_EVIL_CONSTRUCTORS(TypeName)\
 TypeName(const TypeName&); \
 void operator=(const TypeName&);

class Closure
{
public:
 inline Closure(){}
 ~Closure(){}
 virtual void Run() = 0;
private:
 DISALLOW_EVIL_CONSTRUCTORS(Closure);
};

//------------------------------
template <typename class="" typename="" arg1="">
class MethodFunc : public Closure
{
public:
 typedef void(Class::*Callback)(Arg1);
 MethodFunc(Class *object, Callback cb, Arg1 arg) :object_(object), cb_(cb), arg_(arg){}
 ~MethodFunc(){}
 void Run()
 {
  (object_->*cb_)(arg_);
  delete this;
 }
private:
 Class *object_;
 Callback cb_;
 Arg1 arg_;
 DISALLOW_EVIL_CONSTRUCTORS(MethodFunc);
};

template <typename class="" typename="" arg1="">
inline Closure* NewCallback(Class *object1, void (Class::*function1)(Arg1), Arg1 arg1)
{
 return new MethodFunc<class arg1="">(object1, function1, arg1);
}

//---------------------------------------
class CSWFThread
{
public:
 CSWFThread();
 ~CSWFThread();
 int Start(Closure* cb);
 int Stop();
private:
 DISALLOW_EVIL_CONSTRUCTORS(CSWFThread);
 unsigned char m_pImpl[64];
 static void* ThreadFunc(void*);
};

typedef struct SWFTHREAD
{
 pthread_t tid;
 sem_t sem;
 Closure *cb;
}SWFTHREAD;

#define m_pThread  ((SWFTHREAD *)m_pImpl)
#define m_tid      (m_pThread->tid)
#define m_sem   (m_pThread->sem)
#define m_cb   (m_pThread->cb)

CSWFThread::CSWFThread()
{
 memset(m_pImpl, 0 ,sizeof(m_pImpl));
}

CSWFThread::~CSWFThread()
{
 Stop();
}

int CSWFThread::Start(Closure *cb)
{
 sem_init(&m_sem, 0, 0);
 m_cb = cb;
 pthread_create(&m_tid,NULL,ThreadFunc,(void*)m_pThread);
}

int CSWFThread::Stop()
{
 sem_post(&m_sem);
 pthread_join(m_tid,NULL);
 sem_destroy(&m_sem);
}

void* CSWFThread::ThreadFunc(void *arg)
{
 SWFTHREAD *thread = static_cast<swfthread>(arg);
 (thread->cb)->Run();
 sem_wait(&thread->sem);
}

//--------------------------------------
class Test
{
public:
 Test(int i):i_(i){}
 ~Test(){}
 void print(int i){ cout << i << endl; }
private:
 int i_;
};

int main()
{
 CSWFThread thread;
 Test test(1);
 Closure *cb = NewCallback(&test ,&Test::print, 5);
 
 thread.Start(cb);
}