前言
基于对象是从面向对象演变过来的， 面向对象已经诞生了这么长时间，为什么现在基于对象会越来越收欢迎呢？
“成也萧何，败也萧何”
为了解释这个问题，就不得不提到面向对象的三大特征：封装、继承、多态。
这些带来的好处：易维护、质量好、效率高、易扩展、易复用。
同时也带来了很大的坏处： 复杂
但是，在现代的编程语言发展至今，有一个明显的趋势，就是动态化和脚本化。我们可以发现最新兴起的语言，绝大多数都脚本语言，比如Ruby/Lua/Python，而C++语言的新规范，也更多的倾向动态类型推断和lamda表达式（动态函数）。所以面向对象编程概念的发展，也进入了一个更动态化，更脚本化的新时代——基于对象。
封装
在面向对象的过程中，我们把一些逻辑功能和实现其对应功能的属性封装为一个类。
在基于对象中，把所有的在面向对象中的类称为对象，所以在基于对象中，不存在类这个概念。
而且在基于对象中，函数的类型就统一为 function<>,通过回调来实现对应的功能。
继承
面向对象的过程中，我们为了增加代码的复用性，增强了程序的维护性。
在基于对象的过程中，对象之间通过相互组合来"实现"面向对象过程中的继承。
基于对象的缺点
-
从性能角度上来说： 对象之间组合实现的继承的性能是比不上面向对象中继承的性能。
-
所有的函数变量额类型统一后，无法在编译器做任何形式的检查。
-
面向对象中的类类型可读性比较好， 而在基于对象中，函数的类型统一为 function<>，没有任何的可读语义，理解代码比较困难。
举个实例：如果我们需要写一个线程类。
面向对象的手法
先写一个线程基类，然后在子类中实现 run() 函数, 子类调用 父类的start， start 调用 runThread,
runThread 回调 子类实现的 run() 函数 实现具体功能。
baseThread.h
#ifndef BASETHREAD_H_
#define BASETHREAD_H_
#include <pthread.h>
class BaseThread{
public:
BaseThread();
virtual ~BaseThread();
void start();
void join();
private:
static void* runThread(void* arg);
virtual void run() = 0;
pthread_t m_threadId;
};
#endif //BASETHREAD_H_
baseThread.c
#include "baseThread.h"
BaseThread::BaseThread() {
}
BaseThread::~BaseThread() {
}
void BaseThread::start(){
pthread_create(&m_threadId, NULL, runThread, this);
}
void BaseThread::join(){
pthread_join(m_threadId, NULL);
}
void* BaseThread::runThread(void* arg){
BaseThread* thread = static_cast<BaseThread*>(arg);
thread->run();
return NULL;
}
#include "baseThread.h"
#include <iostream>
class Thread : public BaseThread{
void run(){
std::cout << "面向对象" << std::endl;
}
};
int main(){
Thread t;
t.start();
t.join();
return 0;
}
基于对象的写法
实现一个线程对象，在用户态是需要实现对应的回调函数就可。
#ifndef THREAD_H_
#define THREAD_H_
#include <pthread.h>
#include <boost/function.hpp>
class Thread{
public:
typedef boost::function<void ()> ThreadFunc;
explicit Thread(const ThreadFunc& func);
void start();
void join();
private:
static void* runThread(void* arg);
void run();
ThreadFunc m_func;
pthread_t m_threadId;
};
#endif //THREAD_H_
#include "Thread.h"
Thread::Thread(const ThreadFunc& func)
:m_func(func){
}
void Thread::run(){
m_func();
}
void Thread::start(){
pthread_create(&m_threadId, NULL, runThread, this);
}
void Thread::join(){
pthread_join(m_threadId, NULL);
}
void* Thread::runThread(void* arg){
Thread* thread = static_cast<Thread*>(arg);
thread->run();
return NULL;
}
#include "Thread.h"
#include <iostream>
#include <boost/bind.hpp>
void ThreadFunc(){
std::cout << "基于对象" << std::endl;
}
int main(){
Thread t(ThreadFunc);
t.start();
t.join();
return 0;
}