模組化思想：

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();
         });