[软件架构]模块化编程思想及（C++）实践

Repost

内容简介：

             

• 模块化思想
• 模块的构成
• 模块的管理
• 模块化实践
• 定义模块结构
• 声明模块对象
• 定义模块列表
• 模块列表对象

模块化思想

1.     将系统分成很多的模块，模块内部关注自身需要实现的核心业务。

2.     模块化的典型特点是：“模块间的低耦合”和“模块内的高聚合”。

模块的构成

1.     名称。全局范围内表明该模块独一无二的标识。

2.     依赖。称模块运行引用的其他模块为依赖。

3.     接口。将模块对外提供的服务称为接口。

模块的管理

1.     扫描模块列表

2.     分析模块依赖

3.     重排模块顺序

4.     初始化前准备

5.     模块的初始化

6.     模块反初始化

7.     模块最终销毁

模块化实践

#include <vector>
#include <string>
#include <functional>
using namespace std;
  
#ifndef _UNICODE
typedef std::string StdString;
#else
typedef std::wstring StdString;
#endif

定义模块结构

/**
 * 定义初始化及反初始化函数类型
 */
typedef function<void()> SelfFunction;
  
/**
 * 定义模块类型
 */
struct SelfModule
{
         /**
          * 模块的ID
          */
         StdString _id;
  
         /**
          * 模块的依赖，不同的依赖项之间用';'分割
          */
         StdString _depends;
  
         /**
          * 初始化之前的操作
          */
         SelfFunction _preinit;
  
         /**
          * 初始化函数
          */
         SelfFunction _init;
  
         /**
          * 反初始化函数
          */
         SelfFunction _uninit;
};

声明模块对象

/**
 * 声明模块的定义
 */
class DefModule
{
public:
         /*
          * 构造函数
          *
          * @Param id
          *        模块的ID
          * @Param depends
          *        模块的依赖
          * @Param preinit
          *        初始化之前的操作
          * @Param init
          *        模块的初始化函数
          * @Param uninit
          *        模块的反初始化函数
          * @Param destructor
          *        模块的析构函数
          */
         DefModule(StdString id
                   , StdString depends
                   , SelfFunction preinit
                   , SelfFunction init
                   , SelfFunction uninit
                   , SelfFunction destructor);
  
         /**
          * 析构函数
          */
         ~DefModule();
  
protected:
         /**
          * 析构函数
          */
         SelfFunction _destructor;
};
  
/**
 * DefModule
 */
DefModule::DefModule(StdString id
         , StdString depends
         , SelfFunction preinit
         , SelfFunction init
         , SelfFunction uninit
         , SelfFunction destructor)
         : _destructor(destructor)
{
         SelfModuleList* list = SelfModuleList::GetInstance();
  
         size_t offset = 0;
         size_t lastOffset = offset;
         while ((offset = depends.find(';', lastOffset)) != -1)
         {
                   StdString dep = depends.substr(lastOffset, offset - lastOffset);
                   
                   SelfModule& mod = list->FindModule(dep);
                   if (&mod == &SelfModuleList::_NullModule)
                   {
                            SelfModule module;
                            module._id = dep;
                            list->AddModule(module);
                   }
  
                   lastOffset = offset + 1;
         }
  
         SelfModule& mod = list->FindModule(id);
         if (&mod != &SelfModuleList::_NullModule)
         {
                   mod._init = init;
                   mod._uninit = uninit;
                   mod._preinit = preinit;
                   mod._depends = depends;
         }
         else
         {
                   SelfModule module;
                   module._id = id;
                   module._init = init;
                   module._uninit = uninit;
                   module._preinit = preinit;
                   module._depends = depends;
                   list->AddModule(module);               
         }
}
  
DefModule::~DefModule()
{
         _destructor();
}

定义模块列表

/**
 * 模块列表
 */
class SelfModuleList
{
public:
         /**
          * 获取唯一实例
          *
          * @Return 返回全局唯一的实例
          */
         static SelfModuleList* GetInstance()
         {
                   if (_instance != NULL)
                   {
                            return _instance;
                   }
  
                   if (_instance == NULL)
                   {
                            _instance = new SelfModuleList();
                   }
  
                   return _instance;
         }
  
         /**
          * 删除唯一实例
          */
         static void DelInstance()
         {
                   if (_instance != NULL)
                   {
                            delete _instance;
                            _instance = NULL;
                   }
         }
  
public:
         /**
          * 初始化之前的操作
          */
         void PreInits()
         {
                   for (auto iter = _list.begin(); iter != _list.end(); iter++)
                   {
                            (*iter)._preinit();
                   }
         }
  
         /**
          * 初始化函数
          */
         void Inits()
         {
                   for (auto iter = _list.begin(); iter != _list.end(); iter++)
                   {
                            (*iter)._init();
                   }
         }
  
         /**
          * 反初始化函数
          */
         void Uninits()
         {
                   for (auto iter = _list.rbegin(); iter != _list.rend(); iter++)
                   {
                            (*iter)._uninit();
                   }
         }
  
         /**
          * 增加模块
          *
          * @Param mod
          *        模块
          */
         void AddModule(SelfModule mod)
         {
                   _list.push_back(mod);
         }
  
         /**
          * 查找模块
          *
          * @Param id
          *        待查找的模块的ID
          * @Return 返回查找到的模块
          */
         SelfModule& FindModule(StdString id);
  
         /**
          * 模块的空引用
          */
         static SelfModule _NullModule;
  
protected:
         /**
          * 模块列表
          */
         vector<SelfModule> _list;
  
protected:
         SelfModuleList(void) {}
         ~SelfModuleList(void) {}
  
private:
         /**
          * 全局唯一的实例
          */
         static SelfModuleList* _instance;
};
  
/**
 * 模块的空引用
 */
SelfModule SelfModuleList::_NullModule;
  
/**
 * 全局唯一的实例
 */
SelfModuleList* SelfModuleList::_instance = NULL;
  
SelfModule& SelfModuleList::FindModule(StdString id)
{
         for (auto iter = _list.begin(); iter != _list.end(); iter++)
         {
                   if ((*iter)._id.compare(id) == 0)
                   {
                            return (*iter);
                   }
         }
         return _NullModule;
}

模块列表对象

/**
 * 定义当前模块
 */
static DefModule _Module(_T("SelfModuleList")
         , _T("")
         , [](){
         }
         , [](){
         }
         , [](){
         }
         , [](){
                   SelfModuleList::DelInstance();
         });