Visual C++泛型編程實踐

2019-11-17 05:12:35

字體：大中小

來源：轉載

供稿：網友

　　泛型程序設計(Generic PRogramming) 是建立在C++的Template機制基礎上的一種完全不同于面向對象的程序設計思維模式，STL是泛型概念的一套實作產品。Loki是一個與Boost齊名的開放源碼的C++程序庫，它通過一些精巧的裝置為常規C++開發提供了一些很有用的工具。

STL非常好用，彈性非常大，效率也很理想。目前幾種主流的C++編譯器均有相關的STL實現，而個人認為目前非常流行的Visualc++ 6.0平臺中開發文檔應用程序時，其文檔序列化的功能非常好用，但由于其序列化能力建立在MFC之上，并不被STL支持，所以，如何既擁有STL的效率及通用性，又保留MFC的序列化能力，便成了VisualC++ 6.0平臺上運用STL技術開發文檔應用程序時不得不面對的一個問題，在這里我就以非常流行的Visual C++ 6.0+SP5平臺結合一個假定的例子來介紹一下如何在Visual C++6.0中結合使用STL、Loki及模板技術來開發一個文檔應用的開發歷程，希望能對大家有所啟發。

　　示例

　　先來簡單介紹一下我所用到的例子：一個簡單的商務進銷存基本應用（不必關注細節），它應該包含：職員(Employee)、產品(ProdUCt)、倉庫(Storage)、往來單位(Supply)、帳戶(Account)、單據(Bill)等等，由于每種信息均應有唯一標識，所以我在這里選用STL中的map來表示如下（為了說明簡單起見，我們只列兩種）：

std::map＜size,Employee*＞ itsEmployees; 
//職員表
std::map＜size,Product*＞ itsProducts; 
//產品表
..

　　第一步：實現

　　我們將以上map放入多（單）文檔應用程序的文檔類中，很顯然，我們必須對每一個表至少提供以下三種最基本的操作：添加新成員函數、刪除指定成員函數、獲取指定成員函數。

　　對于添加新成員，我們可以實現如下：

size addAccountMember(Account* e); //添加帳戶
{ 
　 //獲取下一個可用的ID號
　 size id=getNextAccountID(); 
　 itsAccounts[id]=e; 
　 returnid; 
}
size addEmployeeMember(Employee* e);//添加職員
{ 
　 //獲取下一個可用的ID號
　 size id=getNextEmployeeID(); 
　 itsEmployees[id]=e; 
　 return id; 
} 
..

　　接下來的刪除方法僅有一個size（唯一標識）參數，實現如下:

void delAccount(size ID); //刪除指定帳戶
{ 
itsAccounts.erase(ID); 
}
void delEmployee(size ID); //刪除指定職員
{ 
itsEmployees.erase(ID); 
}
..

　　獲取指定成員的方法如下：

Account* getAccountMember(size ID) 
//獲取指定帳戶
{ 
return itsAccounts[ID]; 
} 
Employee* getEmployeeMember(size ID) //獲取指定職員
{ 
return itsEmployees[ID]; 
} 
..

　　另外，我們還要為每一個表提供一個獲取下一個可用ID的成員函數：

//獲取下一個可用職員號
Size getNextEmployeeID() 
{ 
　 if(itsEmployees.empty()) 
　　 return 1; 
　 std::map＜size,Employee*＞::iterator it=itsEmployees.end();
　 --it; 
　 return it-＞first+1; 
}
//獲取下一個可用帳戶號
Size getNextAccountID() 
{ 
　 if(itsAccounts.empty()) 
　 return 1; 
　 std::map＜size,Account*＞::iterator it=itsAccounts.end(); 
　 --it; 
　 return it-＞first+1; 
}
..

　　第二步：分析

　　以上實現的確達到了我們的設計目的，但僅從直觀上來看我就覺得它應該還有改善的空間，最簡單的原因：因為它的命名混亂，沒有通用性，如:

addAccountMember, addEmployeeMember,.. 
delAccount, delEmployee,.. 
getAccountMember, getEmployeeMember,.. 
getNextAccountID, getNextEmployeeID,..

　　對于同一種功能存在這么多不同名稱的函數想起來就讓我感到可怕，在我們的這個簡單的例子中只對6個表實現了三種功能，我們需要為每個表實現4種不同名稱的函數，結果，我們需要記住4*6=24個不同名稱的函數及它們所對應的功能，假如，假如我們要對更多的表實現更多的功能..，真的不敢相象我們到底要實現多少個不同名稱的函數。我想，不用等到函數接口數量爆炸，我的腦子就先爆炸了。假如能夠對同一種功能的函數使用一組相同的名字如：

addMember 
delMember 
getMember 
getNextMemberID

　　那么，我們的接口名稱數量就只與實現的功能多少成常數關系，而與我們要操作的表的個數無關了，整個程序就應該清楚多了?！　?STRONG>第三步：改進（重構）

　　重構是一個最近很流行的程序設計思想，說白了就是對已有程序進行改進，在不改變程序外在行為的前提下對程序結構及設計進行改進，以使程序代碼更清楚、程序更健壯、更易于維護。

　　第一次改進：使用函數重載減少接口名稱數量對于添加成員，我們可以直接使用C++的函數重載技術改進如下：

size addMember(Account* e); //添加帳戶
{ 
　 //獲取下一個可用的ID號
　 size id=getNextAccountID(); 
　 itsAccounts[id]=e; 
　 return id; 
}
size addMember(Employee* e); //添加帳戶
{ 
　 //獲取下一個可用的ID號
　 size id=getNextEmployeeID(); 
　 itsEmployees[id]=e; 
　 return id; 
}

　　這樣一來，消除了對不同表進行操作時調用的函數名稱的差異，但我們可以看出，這兩個函數的操作邏輯是完全一樣的，變化的部分與參數相關，這正是模板技術可以發揮作用的地方，但如何將不同的表添加方法與不同的ID號獲取方法及對應的map聯系起來呢？

　　我們再來看刪除函數：由于不同表的刪除方法均只有一個相同類型的參數size ID,而函數重載必須要有不同的參數列表,所以，要想實現一個void delMember(size ID)分別對應不同的表的刪除操作好象是不可能的，getMember(size ID)方法也是一樣，它對不同的表操作雖然有不同的返回值，但參數也是一樣的，所以，也不能運用C++內的函數重載方法來實現函數接口命名的一致化。而獲取下一個可用ID的函數方法甚至連參數都沒有，怎么辦呢？看來我們沒有辦法了。

　　幸運的是，Andrei Alexandrescu在他的《 C++設計新思維——泛型編程與設計模式之應用》一書中為我們提供了一種解決辦法: Type2Type——它是一個可用于代表參數類型，以讓你傳遞給重載函數的輕量級的ID，其定義如下：

Template ＜typename T＞ 
Struct Type2Type 
{ 
typedef T OriginalType; 
};

　　它沒有任何數值，但其不同型別卻足以區分各個Type2Type實體，而這正是我們所要的?，F在，讓我們來先解決addMember成員函數中的獲取下一個可用ID號的函數,我們可以定義一個重載的函數如下：

size getNextMemberID(Loki:: Type2Type＜Employee＞) 
//對應職員操作
{ 
　 if (itsEmployees.empty()) 
　　 return 1; 
　 std::map＜size,Employee*＞::iterator it=itsEmployees. 
　 end();
　 --it; 
　 return it-＞first+1; 
}
size getNextMemberID(Loki:: Type2Type＜Account＞) 
//對應帳戶操作
略..

　　相應的，刪除類函數定義如下:

void delMember(size ID, Loki:: Type2Type＜Account＞) 
void delMember(size ID, Loki:: Type2Type＜Employee＞)

　　獲取類函數定義如下:

Account* getMember(size ID, Loki:: Type2Type＜Account＞) 
Employee* getMember(size ID, Loki:: Type2Type＜Employee＞)

　　這樣，我們的函數接口就比剛開始的方法更清楚，我們的大腦中要記住的函數名就要少多了。
　　第二次改進：使用模板技術減少接口函數數量經過第一次的改進，我們的接口結構比初始的方案要更清楚，但它似乎還存在一個問題：軟件大師Martin Fowler在他的著作《重構——改善既有代碼的設計》中將之列為代碼的壞味道之首——代碼重復。

我們可以看到，添加、刪除、獲取的函數實現中，幾乎完全是一樣的實現邏輯，只不過所操作的map變量不同而已，如下（以添加為例）：

size addMember(Account* e); //添加帳戶
{ 
　 //獲取下一個可用的ID號 
　 size id= getNextMemberID(Loki::Type2Type＜Account＞()); 
　 itsAccounts[id]=e; 
　 return id; 
}
size addMember(Employee* e); //添加帳戶
{ 
　 //獲取下一個可用的ID號 
　 size id=getNextMemberID(Loki::Type2Type＜Employee＞()); 
　 itsEmployees[id]=e; 
　 return id; 
}

　　假如我們能有辦法根據不同的參數獲得不同的要操作的map變量，那么這兩個方法完全可以實現為一個模板方法如下：

template＜typename T＞ 
size addMember(T* e) 
{ 
　 size empid=getNextMemberID(Loki::Type2Type＜T＞()); 
　 //要害在于以下函數
　 std::map＜size,T*＞& its=getMap(Loki::Type2Type＜T＞()); 
　 its[empid]=e; 
　 return empid; 
}

　　假如getMap()方法能實現，那么，我們的模板方法就可以成功。
有了前面的鋪墊，這個應該水到渠成：

std::map＜size,Account*＞& getMap(Loki::Type2Type＜Account＞) 
｛ 
　 return itsAccounts; 
｝
std::map＜size,Employee*＞& getMap(Loki::Type2Type 
＜Employee＞); 
｛ 
　 return itsEmployees; 
｝

　　這樣我們就可以將所有的添加、刪除、獲取函數進行模板化實現如下：

template ＜typename T＞ 
size getNextMemberID(Loki::Type2Type＜T＞) 
{ 
　 std::map＜size,T*＞& its=getMap(Loki::Type2Type＜T＞()); 
　 if (its.empty())
　　 return 1; 
　　 std::map＜size,T*＞::iterator it=its.end(); 
　　 --it; 
　　 return it-＞first+1; 
}
template ＜typename T＞ 
size addMember(T* e) 
{ 
　 size empid=getNextMemberID(Loki::Type2Type＜T＞()); 
　 std::map＜size,T*＞& its=getMap(Loki::Type2Type＜T＞()); 
　 its[empid]=e; 
　 return empid; 
}
template ＜typename T＞ 
T* getMember(size memberID,Loki::Type2Type＜T＞) 
{ 
　 std::map＜size,T*＞& its=getMap(Loki::Type2Type＜T＞());
　 return its[memberID]; 
}
template ＜typename T＞ 
void delMember(size memberID,Loki::Type2Type＜T＞) 
{ 
　 std::map＜size,T*＞& its=getMap(Loki::Type2Type＜T＞()); 
　 its.erase(memberID); 
}

　　這樣，對于本例中6個表分別實現添加、刪除、獲取成員三組方法，我們總共需要用：四個模板化函數、以及一組分別針對6個表的getMap重載函數。然后，我們每增加一個表，只需要為getMap方法添加一個重載的實現，與初始設計中的4*6＝24種名稱各不相同，每增加
一個表支持，要添加4種不同名稱的函數實現的方案比較起來，是不是更清楚、更易維護、易于擴展了呢？

　　第四步：添加序列化支持

　　在本文開頭我提到：Visual c++ 6.0平臺中開發文檔應用程序時，其文檔序列化的功能非常好用，但由于其序列化能力建力在MFC之上，并不被STL支持，如何既擁有STL的效率及通用性，又保留MFC的序列化能力呢？由于篇幅的限制，我以下就只講怎么做，而不講為什么了(參見《MFC深入淺出》)。

　　在這里我們假定map所包含的對象已具備序列化的能力，那么，對于一個map來說，其序列化實現應該如下（以Account 為例）：

void SerializeMap(CArchive& ar,std::map＜size,Account*＞&map) 
{ 
　 typedef std::map＜ size,Account*＞::value_type 
　 value_type; 
　 typedef std::map＜ size,Account*＞::iterator iterator; 
　 if (ar.IsStoring()) 
　 { 
　　 DWord n=map.size(); 
　　 ar.WriteCount(n); 
　　 for(iterator it=map.begin();it!=map.end();++it) 
　　 { 
　　　 ar＜＜it-＞first＜＜it-＞second; 
　　 } 
　 }
　 else 
　 { 
　　 size first; 
　　 Account* second; 
　　 DWORD nNewCount=ar.ReadCount(); 
　　 while (nNewCount--) 
　　 { 
　　　 ar＞＞first＞＞second; 
　　　 value_type value(first,second); 
　　　 map.insert(value); 
　　 } 
　 } 
}

　　將其中的型別相關信息提取出來，利用模板技術就得到一個map的序列化支持函數如下：

template ＜typename Key,typename T＞ 
void SerializeMap(CArchive& ar,std::map＜Key,T＞& map) 
{ 
　 typedef std::map＜Key,T＞::value_type value_type; 
　 typedef std::map＜Key,T＞::iterator iterator; 
　 if (ar.IsStoring()) 
　 { 
　　 DWORD n=map.size(); 
　　 ar.WriteCount(n); 
　　 for(iterator it=map.begin();it!=map.end();++it) 
　　 { 
　　　 ar＜＜it-＞first＜＜it-＞second; 
　　 } 
　 }
　 else 
　 { 
　　 Key first; 
　　 T second; 
　　 DWORD nNewCount=ar.ReadCount(); 
　　 while (nNewCount--) 
　　 { 
　　　 ar＞＞first＞＞second; 
　　　 value_type value(first,second); 
　　　 map.insert(value); 
　　 } 
　 } 
}

　　這樣，我們只需要在文檔類的序列化函數中如下調用：

SerializeMap(ar,itsEmployees); 
SerializeMap(ar,itsAccounts); 
........

　　即可擁有MFC內置的序列化能力了。

上一篇：關于C++異常處理的心得體會

下一篇：VC與Matlab接口編程之Matcom安裝配置

學習交流

索泰發布一款GTX 1070 Mini迷你版本:小機

索泰發布一款GTX 1070 Mini迷你版本:小機箱大愛...

熱門圖片

猜你喜歡的新聞

猜你喜歡的關注

新聞熱點

榮耀總裁趙明烏鎮演講：榮耀首款5G手機V30下月發布

2019-10-23 09:17:05

搜狐張朝陽：回歸媒體是搜狐重新崛起的關鍵

2019-10-21 09:20:02

華為輪值董事長郭平：虛擬技術創造現實價值

2019-10-21 09:00:12

滴滴英文服務上線兩周年用戶已超200萬

2019-09-26 08:57:12

華為推出全球至快AI訓練集群Atlas900

2019-09-25 08:46:36

馬斯克：特斯拉正組建中國技術團隊

2019-09-25 08:15:43

疑難解答

圖片精選

網友關注