c++使用应用框架

在c++的应用过程中，我们经常会发现很多非常有用的c++的应用框架，下面就列出一条在实际开发中很有可能会用到的一种梯形模式

梯形模式的特征：

1> 每一个实例类对应一个相应的接口类

2> 每个实例类中包含有该类对应的接口和上一个实例类的成员变量

3> 最底层需是实例类对应接口，最上层应用只是实例类，没有接口了

4> 所有的接口中需要有一个接口向底层走，同时需要另外一个接口向上层回调，至少得有这两个操作方法

5> 向下接口调用过程中下层实例类中的接口成员需要保存上层this指针用于回调（这是关键）

5> 调用过程中首先app通过最上层类实例化，然后走向下的接口直到最底层，最底层主动调用向上接口到我们需要对外的部分

6> 对外应用的过程中，我们只需要给用户直到的是最外层接口的业务部分和封装好的底层dll即可。

//Devide1.h

<pre name="code" class="cpp">#pragma once
#include "interface.h"

class IInterFace1
{
public:
	virtual ~IInterFace1(){;}

	virtual void fun11(void *) = 0;

	virtual void fun12() = 0;
};

class CDevide1 :
	public IInterFace
{
public:
	CDevide1(void);
	~CDevide1(void);

	virtual void fun1(void *);

	virtual void fun2();

private:
	IInterFace1 *_pInter1;
};

#include "Devide1.h"

CDevide1::CDevide1(void)
{
	printf("CDevide1::CDevide1(void)\n");
}

CDevide1::~CDevide1(void)
{
	printf("CDevide1::~CDevide1\n");
}

void CDevide1::fun1(void *pInter1)
{
	printf("CDevide1::fun1()\n");

	_pInter1 = (IInterFace1*)pInter1;

	fun2();
}

void CDevide1::fun2()
{
	printf("CDevide1::fun2()\n");

	_pInter1->fun12();
}

#pragma once
#include "devide1.h"

class IInterFace2
{
public:
	virtual ~IInterFace2(){;}

	virtual void fun21(void *) = 0;

	virtual void fun22() = 0;
};

class CDevide2 :
	public IInterFace1
{
public:
	CDevide2(void);
	~CDevide2(void);

	virtual void fun11(void *);

	virtual void fun12();

private:
	IInterFace2 *_pInter2;
	CDevide1 _Devide1;
};

#include "Devide2.h"

CDevide2::CDevide2(void)
{
	printf("CDevide2::CDevide2(void)\n");
}

CDevide2::~CDevide2(void)
{
	printf("CDevide2::~CDevide2(void)\n");
}

void CDevide2::fun11(void *pInter2)
{
	printf("CDevide2::fun11(void *)\n");

	_pInter2 = (IInterFace2 *)pInter2;

	_Devide1.fun1(this);
}

void CDevide2::fun12()
{
	printf("CDevide2::fun12()\n");

	_pInter2->fun22();
}

#pragma once
#include "Devide2.h"

class IInterFace3
{
public:
	virtual ~IInterFace3(){;}

	virtual void fun31(void *) = 0;

	virtual void fun32() = 0;
};

class CDevide3 :
	public IInterFace2
{
public:
	CDevide3(void);
	~CDevide3(void);

	virtual void fun21(void *);

	virtual void fun22();

private:
	IInterFace3 *_pInter3;
	CDevide2 _Devide2;
};

#include "Devide3.h"

CDevide3::CDevide3(void)
{
	printf("CDevide3::CDevide3(void)\n");
}

CDevide3::~CDevide3(void)
{
	printf("CDevide3::~CDevide3(void)\n");
}

void CDevide3::fun21(void *pInter3)
{
	printf("CDevide3::fun21(void *)\n");

	_pInter3 = (IInterFace3*)pInter3;
	
	_Devide2.fun11(this);
}

void CDevide3::fun22()
{
	printf("CDevide3::fun22()\n");

	_pInter3->fun32();
}

#pragma once
#include "devide3.h"

class CDevide4 :
	public IInterFace3
{
public:
	CDevide4(void);
	~CDevide4(void);

	virtual void fun31(void *);

	virtual void fun32();

	void start();

private:
	CDevide3 _Devide3;
};

#include "Devide4.h"

CDevide4::CDevide4(void)
{
}

CDevide4::~CDevide4(void)
{
}

void CDevide4::fun31(void *)
{
	
}

void CDevide4::fun32()
{
	printf("CDevide4::fun32()\n");
}

void CDevide4::start()
{
	printf("CDevide4::start()\n");

	_Devide3.fun21(this);
}