[軟件架構]模塊化編程思想及（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();
         });