muduo基于对象编程风格[与]面向对象编程风格对比

结论

muduo代码的实现是基于对象编程风格，使用boost bind/function，替代了mem_fun，ptr_fun，bind1st，bind2nd等函数

boost::bind的使用

示例：boost::bind能够将一个函数接口，转换为另一种函数接口

#include <iostream>
#include <boost/function.hpp>
#include <boost/bind.hpp>
using namespace std;

class Foo
{
public:
	//void memberFunc(Foo* ,double a,int b,int c);
	//实际上是有4个参数，第一个参数默认传入的是this
	void memberFunc(double a,int b,int c)
	{
		cout<<a<<endl; // 0.5
		cout<<b<<endl; // 100
		cout<<c<<endl; // 10
	}
};
int main()
{
	Foo foo;
	boost::function<void (int, int)> fp = 
		boost::bind(&Foo::memverFunc, &foo, 0.5, _1, _2);
	fp(100,10); //等价于(&foo)->memberFunc(0.5, 100, 10);
}
注释：
  # fp是返回值为void，形参为int, int类型的函数指针类型
  boost::function<void (int, int)> fp; 

  # 将Foo的成员函数memverFunc配置成fp类型，参数分别是&foo, 0.5, _1,_2
  # bind的效果为，4个参数配置成2个参数
  boost::bind(&Foo::memverFunc, &foo, 0.5, _1, _2); 

---

面向对象编程风格

面向对象编程风格的实现方式：
(1) Thread中有纯虚函数Run()
(2) 具体类ConcreteThread继承Thread，并重写纯虚函数Run

#ifndef _THREAD_H_
#define _THREAD_H_ 

#include <pthread.h>

class Thread 
{
public:
  Thread();
  virtual ~Thread(); 
  
  void Start();
  void Join();
private:
  static void* Thread_routine(void* arg);
  virtual void Run() = 0; //纯虚函数，给具体类实现
  pthread_t thread_id_;
};

#endif

#include <iostream>
using namespace std;

Thread::Thread()
{
  cout<<"Thread ..."<<endl;
}
Thread::~Thread()
{
  cout<<"~Thread ..."<<endl;
}
  
void Thread::Start()
{
  pthread_create(&thread_id_,NULL,Thread_routine,this);
}
void Thread::Join()
{
  pthread_join(thread_id_,NULL);
}

void* Thread_routine(void* arg)
{
  Thread* ptr = static_cast<Thread*>(arg);
  ptr->Run();
  return NULL;
}

#include "thread.h"

#include <iostream>
using namespace std;

class ConcreteThread:public Thread //具体类，实现基类的纯虚函数Run()
{
private:
  void Run()
  {
    for(int i=0;i<5;i++)
      cout<<"i = "<<i<<endl;
  }
};

int main()
{
  Thread* thread_ = new ConcreteThread();
  thread_->Start();
  thread_->Join();
  delete thread_;

  return 0;
}

---

基于对象编程

基于对象编程的实现方式
(1) 创建Thread类对象的时候，必须传递线程回调函数func作为形参
(2) func函数可能的参数可能会有很多情况，可以通过boost::bind对函数进行适配，适配成typedef boost::function<void ()> ThreadFunc类型

#ifndef _THREAD_H_
#define _THREAD_H_ 

#include <pthread.h>
#include <boost/function.hpp>

typedef boost::function<void ()> ThreadFunc;
class Thread 
{
public:
  expicit Thread(const ThreadFunc& func); //创建线程时，注册ThreadFunc
  virtual ~Thread(); 
  
  void Start();
  void Join();
private:
  static void* Thread_routine(void* arg);
  void Run(); // 不再是纯虚函数，需要自己实现
  pthread_t thread_id_;
  ThreadFunc func_;
};

#endif

#include <iostream>
using namespace std;

Thread::Thread(const ThreadFunc& func):func_(func)
{
  cout<<"Thread ..."<<endl;
}
Thread::~Thread()
{
  cout<<"~Thread ..."<<endl;
}
  
void Thread::Start()
{
  pthread_create(&thread_id_,NULL,Thread_routine,this);
}
void Thread::Join()
{
  pthread_join(thread_id_,NULL);
}

void* Thread_routine(void* arg)
{
  Thread* ptr = static_cast<Thread*>(arg);
  ptr->Run();
  return NULL;
}

void Thread::Run()
{
  func_(); //实际上Run()只是回调了func_()函数
}

#include "thread.h"
#include <boost/bind.hpp>

#include <iostream>
using namespace std;

void func_1()
{
  cout<<"func_1()..."<<endl;
}
void func_2(int count)
{
  while(count--)
  {
    cout<<"func_2()..."<<endl;
  }
}
class Foo
{
public:
  void func_3(int x)
  {
    while(x--)
    {
      cout << "x = " << x <<endl;
    }
  }
};
int main()
{
  Thread* t1 = new ConcreteThread(func_1);
  t1->Start();
  t1->Join();
  
  Thread* t2 = new ConcreteThread(boost::bind(func_2, 3));
  t2->Start();
  t2->Join();

  Foo foo;
  Thread* t3 = new ConcreteThread(boost::bind(&Foo::func_3, &foo, 1000));
  t3->Start();
  t3->Join();
  
  return 0;
}