面向对象和基于对象

前言

基于对象是从面向对象演变过来的， 面向对象已经诞生了这么长时间，为什么现在基于对象会越来越收欢迎呢？

“成也萧何，败也萧何”

为了解释这个问题，就不得不提到面向对象的三大特征：封装、继承、多态。

这些带来的好处：易维护、质量好、效率高、易扩展、易复用。
同时也带来了很大的坏处： 复杂

但是，在现代的编程语言发展至今，有一个明显的趋势，就是动态化和脚本化。我们可以发现最新兴起的语言，绝大多数都脚本语言，比如Ruby/Lua/Python，而C++语言的新规范，也更多的倾向动态类型推断和lamda表达式（动态函数）。所以面向对象编程概念的发展，也进入了一个更动态化，更脚本化的新时代——基于对象。

封装

在面向对象的过程中，我们把一些逻辑功能和实现其对应功能的属性封装为一个类。

在基于对象中，把所有的在面向对象中的类称为对象，所以在基于对象中，不存在类这个概念。

而且在基于对象中，函数的类型就统一为 function<>,通过回调来实现对应的功能。

继承

面向对象的过程中，我们为了增加代码的复用性，增强了程序的维护性。

在基于对象的过程中，对象之间通过相互组合来"实现"面向对象过程中的继承。

基于对象的缺点

• 从性能角度上来说： 对象之间组合实现的继承的性能是比不上面向对象中继承的性能。

• 所有的函数变量额类型统一后，无法在编译器做任何形式的检查。

• 面向对象中的类类型可读性比较好， 而在基于对象中，函数的类型统一为 function<>，没有任何的可读语义，理解代码比较困难。

举个实例：如果我们需要写一个线程类。

面向对象的手法

先写一个线程基类，然后在子类中实现 run() 函数, 子类调用 父类的start， start 调用 runThread,
runThread 回调 子类实现的 run() 函数 实现具体功能。

baseThread.h

#ifndef BASETHREAD_H_
#define BASETHREAD_H_

#include 


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 

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 
#include 


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 
#include 


void ThreadFunc(){

	std::cout << "基于对象" << std::endl;
}


int main(){

	Thread t(ThreadFunc);
	t.start();
	t.join();


	return 0;
}