Linu插件框架实验报告.doc

电 子 科 技 大 学
实 验　 报　 告
学生姓名: 　 　 　 学 号:　 　 指导教师:
实验地点:Ａ2-412　　　　　 实验时间:2012、01、0４
一、实验室名称：
Linux环境高级编程实验室
二、实验项目名称:
插件框架实验
三、实验学时:
4学时
四、实验目得:
学习与实践插件框架得开发。理解插件得工作原理,为进一步开发高可用,高复杂度得插件打下基础。
五、实验内容：
１、使用动态链接库实现打印功能:
开发一个程序,向屏幕打印“Hｅllo Worlｄ”;在不重新编译链接原程序得前提下,将打印得文字改为“Hello China”。
2、使用动态链接库实现自定义打印功能:
同时要打印“Heｌlo Worｌｄ”,打印“Heｌｌo　Ｃhina”,甚至同时打印未来才会增加得其她打印信息,打印信息得链接库放在一个固定目录中,遍历这个目录，获取所有动态链接库。
打印未来得这些信息，也不能重新编译链接原程序。
3、
1）通过命令行方式:、／a、ｏut ｈeｌｐ,输出所有插件实现得功能ID,以及该功能ＩD对应得功能描述。
2)通过命令行方式：、/a、out ＦｕｎcＩD,调用具体打印功能(每个插件导出ＧeｔID接口）。
4、将插件导出得Ｐｒint、GｅtＩD、Hｅlｐ三个函数放在一个类中,主程序需要使用多个容器分别保存这些函数地址,让插件外部获取该类得对象。
综合练习:实现一个软件系统,该系统可对文件进行统计分析。究竟对文件进行什么样得统计分析,最终用户自己也不就是很清楚,目前只知道需要统计文件得行数。也就就是说,本软件系统将会随时面临,增加文件统计新功能得难题。请结合本实验内容,设计并实现这样一个面向文件统计功能得插件系统。（需要实现得插件包括：统计某个文件得行数,统计某个文件得字节数)
六、实验步骤:
程序1：
A. h:
eｘteｒn "c" vｏiｄ　f();
a2、cpp:
#incluｄe<iostｒeam>
#ｉnclude＂ａ、h"
using ｎamespacｅ ｓtｄ;
void f(）
{
couｔ ＜＜　"ｈellｏ,Ｃhina!＂　<< ｅndｌ；
}
A１、cpｐ:
#ｉｎclｕdｅ<iostreaｍ>
＃ｉｎclｕｄｅ"a、ｈ＂
uｓing namｅｓpaｃe sｔｄ;
voｉｄ f()
｛
　 cout <＜ "Helｌo,Word＂　<< eｎｄｌ;
}
Mａin、cpｐ:
#includｅ"a、h"
#inclｕdｅ<dｌｆcn、h＞
#inｃlｕｄe<iostream>
using namｅspacｅ ｓtd;
int main（)
{
void *hａndｌｅ ＝ dlopeｎ(＂、/libｔｅｓｔ、ｓo", ＲTLD_LAZY);
if(０ ＝= ｈａnｄle)
｛
ﻩcout <<　"dlｏｐen erｒor" << ｅnｄl;
ﻩ return 0;
　 }
tyｐedef voｉｄ　(*Fun)();
　Fｕn　f1　＝　(Fun)ｄlsｙm(handle，　"f"）;
　　 if(0 == f1)
　{
ﻩﻩｃout　＜< "f1　eｒｒoｒ"　＜＜ ｅndl；
　 ｃhａr *str　＝ dlerror();
ﻩ ｃouｔ ＜＜ str　＜＜　ｅndl；
　 　 }
　　(＊f1）()；
dｌclose(handｌe）;
　 　　return　0;
}
程序运行结果如图１所示:

图1：字符得变换
程序２:
A１、cpp:
#include＜iｏｓtｒｅam>
using namespace stｄ;
eｘterｎ"C"　void　ｆ()
{
ﻩcout　＜<　"Hellｏ ｗoｒld" << eｎｄｌ；
}
A2、ｃpp:
#incluｄe＜iostream>
usｉnｇ namespace std;
ｅxtern "Ｃ"　ｖoｉｄ f()
{
cout <＜ "Helｌo,cｈina！" <＜　endl；
｝
A3、cpp:
#inclｕde<ｉostrｅam＞
using naｍespaｃｅ std;
eｘtern "C＂　void f()
{
ﻩcout << "Heｌｌｏ 3３3"　<< eｎｄl;
}
A4、ｃpp:
#inｃluｄe<iostｒeaｍ＞
usinｇ ｎamespace std;
extｅrn "C＂ ｖoｉd f(）
{
ﻩcoｕt ＜< "Hello　４444" <<　enｄｌ；
｝
Tｅｓt2、cpp：
#inｃludｅ<dlfcn、h>
#iｎｃlude<iostreaｍ>
#incｌuｄe<dirｅnｔ、h>
#ｉnｃluｄe<sｔdio、h>
#inｃｌｕde<strｉnｇ、h>
using namespaｃｅ sｔd;
int　mａiｎ（)
{
ﻩchａr paｔh[2６０];
ﻩＤＩＲ *dir;
ﻩstｒｕct 　ｄireｎt　 *pｔr; 　
ﻩｄiｒ=ｏpeｎdｉr(＂/root/test/tesｔ4/plｕｇ2/plugｉｎ/");
ﻩwhile(（ptr=ｒeaｄdir(diｒ)）!=NUＬL)
{
ﻩ iｆ ((ｓｔrcmp(ｐtr->d_nａme，＂、、")＝＝0)|｜(strｃｍp(ptr－>d_ｎaｍe,"、")==0))
ﻩ{
ﻩﻩcｏntinｕe;
}
ﻩ sprｉｎtｆ（path,＂/rｏot／test/ｔest4/pｌug2/plugin／%s",　pｔr->d＿ｎame）;
ﻩｖoid　*ｈaｎdle　＝ dlｏpeｎ(ｐａth,　RTLD_ＬAZＹ)；
　 if(0 == hａndle）
　 {
ﻩｃｏuｔ <<　＂dlopｅn erｒｏr" <＜ enｄl;
ﻩﻩ reｔｕrn　0；
　 ｝
ﻩ ｔｙpeｄef void （*Fｕn)（）;
　Ｆun　pf =　(Fun）dlsym(hanｄlｅ, ＂ｆ");
ﻩ 　　　if(0 ＝= pｆ)
ﻩ　 ｛
coｕt　<<　"pf error" <<　eｎｄl;
　 cｈaｒ *sｔr = dlerroｒ（);
ﻩ ﻩcout << sｔｒ << ｅndｌ;
ﻩ rｅturn　0;
ﻩ 　 ｝ﻩ
ﻩ (*ｐf)();
ﻩﻩｄlclose(haｎdlｅ); 　
}
ﻩclosｅdir(ｄiｒ);
}
程序运行结果如图2所示：

图2:插件得遍历
程序３：
a1、ｃpp:
#includｅ ＜iostｒｅａｍ>
usiｎｇ　namｅspａce sｔd;
const　int FＵNC_ID = １;
exｔｅrn　＂C" ｖoiｄ f()
｛
　cout　<<　＂Helｌo Wｏrld!＂ ＜＜ ｅnｄｌ;
}
eｘtern　"Ｃ"　void Hｅlp()
{
　 cout <＜　＂Fｕnctioｎ IＤ " ＜< FUＮＣ＿ＩD << ＂ ： Tｈis functｉｏn prｉnｔｓ　Ｈｅｌlo Woｒｌd、" ＜< endl；
}
ａ２、cｐp：
#incluｄe　＜ioｓtｒeａm>
using namespａcｅ std；
ｃonst ｉｎt FUNC_ID =　2;
extern "C"　ｖoid f(）
{
　　 ｃｏut << ＂Ｈｅllo Cｈｉna!" <＜ ｅndl;
}
extern　"Ｃ＂　ｖoid Ｈｅlp()
{
cout ＜＜　"Fuｎction ＩD "　<<　FUＮＣ_ＩD　<<　" Thｉｓ ｆｕnｃtion priｎｔs helｌo china、＂ ＜< ｅｎdl；
}
CPｌｕgｉnEnumeｒａtor、cpp
#iｎclｕde　＂ＣPlugｉnEｎumeｒatoｒ、h"
#ｉｎｃlude　<dirent、h>
#includｅ <ｓｔrinｇ、h>
＃ｉncｌude ＜iostrｅam>
#inｃｌude ＜stdio、h>
CPlugiｎEｎｕmeｒatoｒ::CPlugiｎＥnuｍeraｔor()
{
}
CＰlｕginEnｕmerａtoｒ::~CPlｕgiｎEnumeｒａtor(）
{
}
bool CPlｕgｉnEnuｍｅrａtor::ＧｅtPluginNames（veｃtｏr<sｔｒｉng＞& vstrPluginNａｍes)
{
　　 DIR *diｒ　= openｄiｒ("/ｒｏｏt/tｅst/tｅst4/pｌug３／ｐlｕｇｉn");
　 if(dir == 0）
ﻩﻩreturn　ｆalsｅ;
　foｒ(;;）
{
struct　dｉrｅｎt *ptr　= readdir(dir);
ﻩif（ptr ＝= 0)
ﻩ breaｋ；
if(（strcmp(ptr-＞d＿name, ＂、＂) ＝= 0)||(stｒcmp(ptｒ-＞d_nａmｅ,　"、、＂） ==　0))
ﻩ contiｎuｅ;
ﻩchａr pａｔh[260］;
ﻩﻩｓprintf(path， "/rｏot/tｅst/test4/plug3/pluｇin/%s",　ｐtr->d＿name);
ｖｓtrPluｇinNames、pｕsｈ_ｂack(pａtｈ);
　 }
closeｄir(dｉr）;
ﻩｒｅtｕｒn truｅ;
}
Test、ｃpp：
#iｎｃluｄe <dlfcn、h>
＃iｎclude ＜ioｓtｒｅam>
#iｎcｌｕdｅ "CPlugｉnEnumerａtor、h"
#includｅ <string、h＞
#ｉｎｃlude <stdio、h＞
using　ｎaｍesｐａce　sｔd;
iｎｔ main(ｉｎt argｃ, char　**argv)
{
ﻩchａr　path ［2６0]；
　if(aｒgｃ != ２)
ﻩrｅtuｒｎ 0;
　 ｉf(stｒｃmp(arｇv[１]， "help"） == ０)
｛
vector＜sｔrｉng>　ｖｓｔrPlugｉｎNames;
CPlugiｎＥnuｍeｒator　eｎｕmerａtor;
　 iｆ（!enｕmeｒatｏr、GetPlugiｎNamｅs(ｖsｔrPluginNａｍes))
　　 ﻩ{
ﻩ ﻩcout <＜ ＂ＧetPｌuginNａmｅｓ eｒror" ＜＜ ｅnｄl；
ﻩ return　0;
　　　　 }
　ﻩｆor(int i = 0； i< vstｒPluginNames、siｚｅ();　ｉ++)
｛
ﻩﻩvｏid　＊handle = dｌopen（vstrPlｕginNames[ｉ]、ｃ_ｓtｒ（), RTLD＿ＬAZＹ);
ﻩ ﻩiｆ(hａnｄlｅ　=＝ ０）
ﻩﻩ {
ﻩﻩ ｃout ＜< ＂ｄlopeｎ　errｏr" << eｎdl;
ﻩ 　 ｒｅtuｒn 0;
}
ﻩﻩﻩtypeｄef void （*FＵNＣ_HELP)();
ﻩ FUNC_HＥLP　dl_ｈelp = (FUNC_ＨELP)dlsym（hanｄle， "Help");
ﻩ if(dl_helｐ　=＝ 0)
ﻩﻩ｛
ﻩﻩ ﻩｃout << ＂dlｓym eｒror＂　<<　endl;
　ﻩ reｔuｒn ０；
}
ﻩﻩ (dl_hｅlp）(）;
ﻩ ｄlｃｌoｓe(ｈandle）;
ﻩﻩ}
ﻩ}
ﻩｅlse ｉf（strcmp(argv[1］, "1") =＝　０)
ﻩ{
spriｎtｆ(pａth, ＂/rｏot／test/ｔest４/plug3/plugin/%s",　"a１、ｓo");
ﻩvoiｄ *ｈanｄｌｅ = dlｏpen(ｐaｔｈ, RTLD_LＡZＹ);
ﻩ if(ｈａｎdle =＝　０）
ﻩ｛
ﻩﻩ cout　<<　"dlopeｎ eｒrｏr" << endl;
ﻩ rｅｔurｎ 0;
}
typedef　voｉd　(*FUNC_PRINT)(）；
ﻩﻩFＵＮC_ＰRIＮＴ dl_prinｔ ＝ (FUNＣ＿ＰRINT)ｄlsyｍ(handle， "f");
ﻩ ｉf(ｄl_ｐｒiｎt =＝ ０）
ﻩﻩ｛
ﻩﻩｃout　<<　"dlsym　eｒror" ＜＜ endl;
reｔurｎ 0;
ﻩﻩ}
ﻩ（ｄl＿print)(）;
ﻩ dｌclｏｓe(handle);
ﻩ}
eｌse iｆ(strcmp(aｒgv[1], "2") == ０）//　得到第二个fｕnc得参数
ﻩ{
ﻩ ｓprintf(path, "/root/teｓt／teｓt４/plug３/pｌugin/%ｓ＂， "a2、so")；
ﻩｖoｉd *hanｄlｅ = dlｏpen(ｐath, RTLD_LAＺＹ);
if（hａnｄle ＝＝　０)
ﻩ {
ﻩ ｃout << "ｄloｐｅn ｅｒｒor" << eｎdl;
ｒeturｎ ０;
ﻩ}
tyｐｅｄef voｉd　(*FＵＮＣ_PＲＩNT)(）;
ﻩFUNC_PRINＴ dl_print = (ＦUNC＿ＰRINT)dlｓyｍ(haｎdｌｅ,　＂f＂);
if（dｌ_print == ０)
ﻩ{
ﻩcout　<< "dlsym error" << ｅndl;
retuｒn 0;
}
ﻩ(dｌ_print）();
ﻩﻩdｌｃlose(hanｄle);
｝
ﻩrｅturn 0;
}
程序运行结果如图3所示:

图3:插件输出
程序4:
CPlugiｎEnumeｒator、h：
#ifnｄｅｆ CPＬUＧINEＮUMＥRＡTOR＿H
#deｆｉnｅ CPLUGINENUＭEＲATOＲ_H
#ｉnｃlｕdｅ　<vector>
#ｉnｃlude <string>
uｓinｇ nameｓｐace　std;
clａss CPluｇinＥnｕｍeraｔoｒ
｛
puｂlｉc:
　 CPluｇiｎEnumｅratｏr();
virtｕal　~CPlugｉnEnumeraｔor(）；
　bool GeｔＰlugｉnNames（vｅctor＜ｓtring>&　ｖstrPｌuｇｉnNａmes);
};
#ｅｎdif
CＰluginEnｕmeratoｒ、cpp：
#include "ＣPlugiｎEｎumerａtor、h"
#ｉncludｅ <dirｅnｔ、ｈ>
#incluｄe　<stｒinｇ、h>
CPlｕｇiｎEnumerａｔor：:CPluginEnumeｒａtor（)
{
}
CPｌuginEnumerａtor::～CＰlugｉｎEnｕmerａtoｒ()
｛
}
boｏl ＣＰlｕginＥnumｅｒａtor：:ＧetPlugｉnNａmes(vｅｃtor<stｒing＞&　vｓtｒPｌｕginＮameｓ）
｛
DＩR *diｒ　= ｏｐendir(＂、／plｕgiｎ＂）;
　 if(dir ＝= 0）
retｕrｎ falsｅ；
　　 for(;；）
　｛
ﻩstrｕct direｎｔ　*pentry = reａdｄiｒ(dir);
ﻩif(pentry　＝= 0)
brｅaｋ;
if（ｓtｒcmp(ｐｅntrｙ->d_namｅ, ＂、＂) == 0)
　 　ｃｏntinｕｅ;
ﻩif（ｓtrｃmp(pｅnｔry->d_name, "、、"） ＝= 0)
ﻩ 　 contｉnｕe；
ﻩsｔriｎg stｒ = "、/plugin/";
sｔr ＋= ｐeｎｔry-＞d_nａmｅ;
ﻩvstｒPluginＮames、pｕsｈ_bａck(str）;
　　　 }
　 ｃｌosedir(ｄir）;
　　 rｅtuｒn tｒue；
}
CＰluginCoｎtｒoller、h
#ifnｄｅｆ　ＣPＬＵGＩNCＯＮＴROＬLER_Ｈ
＃dｅfine CＰLUGINCOＮTRＯＬLER_Ｈ
#ｉｎclude　＜vectoｒ＞
clasｓ　IPriｎtPlｕgin;
ｃｌaｓs CＰｌuginCｏntroｌler
{
ｐublｉc:
ﻩCPｌugiｎCｏntrollｅｒ(void);
vｉrｔual ~CPluｇiｎConｔrolleｒ(ｖoid);
bool InitializeCｏntｒollｅｒ(voｉd)；
booｌ ＵｎｉnｉtializeCoｎtrｏllｅr(void);
ﻩbｏol　ＰｒoｃessHｅlｐ(voｉd）；
boｏl ＰroceｓｓRequｅst（int FunｃｔｉｏnIＤ);
pｒiｖatｅ:
stｄ::veｃｔor<ｖｏｉd *> m_vhFoｒPluｇｉn；
ﻩstd：:vｅctor<IＰrintPlugin＊＞　m_vｐＰluｇin;
}；
＃enｄｉf
ＣPｌuginCoｎtｒｏller、cpp
#inclｕde "CPluｇinConｔrolleｒ、ｈ"
#iｎclｕde "CPｌuginEnｕmeｒator、h"
＃includｅ "ＩPrintPlugin、ｈ"
#incｌｕdｅ "dlｆｃn、h"
CPluｇinController：：CPluginControllｅｒ(void)
{
}
ＣPlｕｇinConｔrｏlleｒ::~CPluginContｒoller(vｏid）
{
}
ｂoｏl CＰluginContｒoｌlｅr:：IniｔｉａlizeCoｎtｒoller(voｉd)
｛
ﻩstd::vector<stｄ::strｉng> vｓtrPluginＮames;
CＰlｕginEnumeｒatｏｒ　enｕmerａtoｒ;
ｉf(!enumeratｏr、ＧetＰｌuginＮamｅs(vstrＰluginNameｓ))
ﻩretｕｒn fａlse;
ﻩfor(unsｉgned iｎｔ i=０ ; i<vsｔｒPlugiｎNames、siｚe（); i+＋)
｛
ﻩtypｅdｅf int (*PLUＧIN_ＣRＥATＥ)(IPrintPlugin＊*);
ﻩＰLUGIN_CREＡTＥ ＣreatｅPｒoc；　
IPrｉntPｌｕｇｉｎ *pPluｇin = NULL;
ﻩvｏid* hiｎsｔLib = ｄlopen(ｖstrPlｕｇｉnNａｍes［i]、c＿ｓtr()， RTＬD＿ＬAＺY);
ﻩiｆ(hiｎｓtＬｉb !＝ ＮULＬ）　
ﻩﻩ{
ﻩﻩﻩm_vhForPlugin、push_bacｋ(hinstＬiｂ);
ﻩ CｒeatePrｏc = (PLUGIN_CREAＴE)ｄlｓym(hｉnｓｔLib, ＂CrｅatｅObj＂);
ﻩﻩ iｆ(NULL ！＝　CrｅaｔePrｏc)
{
ﻩ ﻩ (CreａtePrｏc）（＆pPlugin);
ﻩﻩ if(pPｌugin != NＵLL)
ﻩﻩ ﻩ｛
m_vpPlugiｎ、ｐush_ｂack(pPlugｉn);
ﻩﻩﻩ｝
ﻩﻩ｝
}
}
ﻩｒetｕｒn ｔrue;
｝
bｏoｌ CＰluｇｉnＣｏｎtroller::ProcｅssRequｅst(ｉｎt FunｃtｉonIＤ)
{
ﻩfoｒ(unsｉｇned int i =　0; i <　m_vpＰlugin、size(); ｉ++)
ﻩ{
ﻩ ｉf（m＿ｖｐPlugｉn[i]－>GeｔID（) == FunctｉoｎIＤ)
{
ﻩ m_vpＰｌuｇiｎ[i]->Priｎｔ（);
ﻩ ﻩbrｅak;
ﻩﻩ}
}
ﻩrｅturn　true;
}
ｂool　CPlugiｎController::ProcessHelp(ｖoid)
{
std::vecｔor<stｄ::stｒing＞　vsｔrＰluｇｉnNaｍeｓ;
ＣＰlugｉnEnｕmeratoｒ enｕmeratｏｒ;
if(！enumｅraｔor、GeｔPluginNaｍes（vstrPlｕginＮaｍeｓ))
retｕrn false;
ﻩｆor(unsiｇneｄ　int ｉ=0 ; ｉ＜vstrＰlugｉｎＮaｍes、size（); ｉ＋+)
｛
ﻩtyｐedef int (＊PLＵGIN_CREATE)(IPrｉnｔPlｕgｉｎ＊＊);
ﻩPLUGIN_ＣRＥＡTE ＣreatｅＰroc;　
IPrintPlugin *ｐＰlugin　= NUＬL；
ﻩ voｉｄ＊ ｈinsｔＬiｂ　=　dｌopen（vsｔｒＰlugiｎNames[ｉ]、c_str（）， RTLD＿ＬAＺＹ）;
ｉf（hinsｔＬｉb !＝　NULＬ)
ﻩ {
ﻩ ﻩCreatePｒoc　＝　(ＰＬUＧIN_CREATE)dlsyｍ(hinsｔＬｉb, ＂CreateＯbｊ");
ﻩﻩ if(NULL ！= ＣreａteProc)　
ﻩﻩ {
ﻩ ﻩﻩ(ＣreatePｒｏc)(&pPluｇｉn);
ﻩ ｉf(pPlｕｇin ！= NULL)
ﻩﻩ ﻩ{
ﻩ ﻩpＰlugin-＞Ｈｅlp()；
ﻩﻩ }
ﻩ ﻩ}
ﻩﻩﻩdlｃloｓe(ｈinstLiｂ);
ﻩﻩ}
}
ﻩｒeｔurn tｒue；
}
bｏｏｌ　CPluginController：:UnｉnｉtｉalizｅＣontrollｅr()
{
ﻩfor(ｕｎsigned iｎｔ i = ０; i ＜　m_vhForＰlugin、siｚe(); i++)
{
ﻩdlclｏsｅ（m_vhFｏrPlｕgin[i]);
}
retｕrｎ true;
}
IPrintＰluｇin、h
#pｒaｇma　once
cｌaｓs IPrintPｌugin
{
public:
ﻩＩＰrintＰlｕgｉn（）；
ﻩviｒtual ~IPｒｉｎtPｌuｇｉn()；
ﻩｖirｔual ｖoid　Ｈeｌp()　= 0;
ﻩvirtuａl void Print() = 0;
ﻩviｒtuａｌ inｔ　GeｔID（）　= ０;
};
ＩＰrｉｎｔＰlｕgiｎ、cpｐ
＃incｌｕde ＂IPｒｉntＰlugin、ｈ"
IPrintPlugin:：ＩPrintPｌugin()
｛
}
IＰriｎtPlｕgｉn::~IPｒintＰlｕｇin()
{
}
Function、cpｐ
#iｎcluｄｅ　<ioｓｔream＞
#inｃlude　"ＩPrinｔPlugin、h＂
ｕsiｎg　ｎａmesｐacｅ std;
ｃonst iｎｔ　FUＮC_IＤ　= 1;
ｃlass　CPｒinｔPluｇin ：　public ＩＰｒｉntPlugｉｎ
｛
public:
CPｒiｎtPlugｉn()
ﻩ｛
ﻩ}
viｒtual ~CPｒintPlugin()
{
ﻩ}
virtual　vｏid　Print（）
ﻩ｛
ﻩ ｃoｕt << "Heｌｌo　Woｒｌd!＂ << enｄl;
ﻩ}
ﻩvirｔuａｌ vｏid Heｌp（)
{
ﻩcｏuｔ <<　＂Fｕnctioｎ ID " <＜ ＦUＮC＿ＩD ＜<　" ： This ｆuｎｃtiｏn will prinｔ helｌo worｌd、" <<　endｌ;
｝
ﻩvirtｕａl ｉnt　GeｔID（voｉd)
ﻩ{
return FUＮC_ＩＤ;
ﻩ｝
｝;
exｔern ＂C＂　voｉd　CｒeatｅＯbj（IPrintPlugｉｎ **ｐpPlugin)
{
ﻩstａtic CPｒｉntPｌugｉｎ plugin;
ﻩ*ppＰlｕgin =　&pluｇin;
}
functｉoｎ1、cpp
＃iｎcluｄe <iosｔream>
#inclｕdｅ ＂IＰrintＰｌugｉn、ｈ"
using nａmespａｃe std;
conｓt ｉnt FＵＮC_ＩD　＝ ２;
claｓs ＣPrｉｎtPlugiｎ ：　pｕｂlic IPrintＰlugin
{
pubｌiｃ：
CPrintＰｌｕgiｎ()
ﻩ{
ﻩ｝
vｉrtuａl ~CPｒintPｌｕgｉn(）
{
ﻩ}
viｒtual void　Print(）
｛
ﻩﻩcｏuｔ << "Hello Chinａ！＂ ＜< eｎdl；
}
virｔｕal vｏid Hｅlp()
｛
ﻩ cout ＜< "Functiｏn　IＤ " <<　FUNC_ＩD << ＂　: This　fuｎcｔion wiｌｌ pｒint ｈellｏ chｉna、" <＜ endl；
}
ﻩviｒtual　iｎt GｅtＩD(void)
{
reｔurn FUNC＿ID;
}
｝；
exｔern　＂C＂ void CreａteObj(IPrintPlｕgin　**ppＰluｇin)
{
ﻩstatic CPrｉntPlugｉn pｌｕgｉn;
ﻩ*ｐｐPluｇｉｎ　= &pluｇin;
}
Main、ｃpp
#inｃludｅ <iｏsｔreaｍ>
＃ｉnclude "CPluginCｏntｒoｌｌer、h"
#incｌｕdｅ <ｓtrｉng、h>
＃incluｄe　<ｓtｄｌiｂ、h>
ｕｓing namesｐace　std;
ｉnｔ maiｎ(iｎｔ argc, chａr **arｇv)
{
iｆ(argc　!= ２)
ﻩ｛
ﻩ cout << "Paｒameters　error" <＜ eｎｄｌ;
ｒetｕrn　0;
ﻩ}
ﻩｉf(ｓtrcmｐ(aｒｇv[1]， "ｈelｐ＂) ＝= 0)
ﻩ｛
ﻩﻩCＰluｇｉｎＣontroｌｌer pc;
pc、PrｏcessHeｌp(）;
ﻩreturn 0；
｝
ﻩint FuncｔｉｏnID = ａｔoｉ(argv[1]);
ﻩＣＰluｇinCoｎtrｏlｌer pｃ;
ｐｃ、InｉtｉalizeContｒｏller(）;
ﻩpc、ProｃesｓReｑｕｅst(ＦunｃtｉonID);
pｃ、UnｉｎiｔialｉzeCoｎtｒｏｌlｅr();
return　0;
}
程序运行结果如图4所示：

图４:插件获取类对象
综合练习:
CPlugiｎＣontrollｅr、ｃpp
＃include ＂CPluginCoｎtrｏｌler、h"
#incluｄｅ　＂ＣＰluginEnumeｒaｔｏr、h＂
#inｃlude "IPｒintPlugin、h"
＃inclｕde "ｄlfｃn、h＂
＃iｎｃlude <striｎg、h>
CPlｕginControlleｒ:：CPｌuginCｏｎtrollｅr（voiｄ)
{
｝
CPluｇｉnCｏntｒoｌler::～CPlｕginＣonｔrｏller(vｏｉd)
{
}
bool　CPluｇinControｌler::IniｔiaｌｉｚeCｏｎtｒoller(ｖoiｄ)
｛
ﻩsｔｄ::veｃtor<sｔｄ::string＞　vｓtｒPluginNameｓ;
ﻩＣＰlugｉnEｎumerａtor enuｍerａtor;
ﻩｉｆ(！enumｅｒatｏr、ＧｅtPluginＮａmes(ｖｓtrPluginNames))
ﻩreｔurn ｆａlse;
for(ｕnsigned inｔ i＝0　; i<vstrPlｕgiｎNameｓ、size();　i++)
ﻩ{
ﻩ tｙpｅdｅf　int (*PLUGIN_CRＥATE）(ＩPrｉｎtPluｇin**）;
ﻩPLUGIＮ＿CREＡTE　CreaｔePｒoｃ;
ﻩﻩIＰriｎｔＰluｇｉn *ｐＰｌｕgiｎ = ＮＵLL;
ﻩ ｖｏid* hinsｔLib ＝　dｌｏｐｅn(vsｔrPlｕginNamｅs[ｉ]、c＿ｓtr()，　RTLＤ＿LＡZY）;
ﻩ if（hinstLib ！＝ ＮULL)　
｛
ﻩﻩﻩm＿vhForPluｇｉn、pｕｓh_back(ｈｉnstＬib）;
ﻩﻩ CreaｔeＰｒoｃ =　(ＰLＵGIN_ＣＲEATE)ｄlｓym(ｈｉnstLib, ＂CｒeateObj");
if（ＮUＬL !＝ CreatePｒｏｃ)　
{
ﻩ ﻩﻩ(CreateProc)(&pＰｌｕｇin);
ﻩ ﻩiｆ（pPlｕgin ！= ＮＵLL)
ﻩﻩﻩ{
ﻩ ﻩﻩﻩm_vｐPlugｉn、puｓh_baｃk(pPｌuｇin);
ﻩ }
｝
}
}
ﻩretｕrn　true;
｝
bｏｏl CPluginＣontrolｌｅｒ::PrｏcessRequest（int FuｎctioｎＩＤ)
{
for(unｓigｎed ｉnt i = 0；　i < m_vｐPlugin、size(）; i++)
{
ﻩiｆ（m_ｖｐPlugｉｎ[i]-＞ＧetID() ＝= FunctｉonIＤ)
ﻩ ｛
ﻩ m_vpPlugin[ｉ]-＞Prｉnt(）；
ﻩbｒeａｋ;
｝
ﻩ}
return true;
｝
bool CPlugｉｎCｏｎtｒollｅr:：PｒocｅssＨelｐ(voiｄ)
{
ﻩｓtd::vector<ｓｔｄ::stｒing＞ vstrＰlugiｎNamｅs；
ﻩCＰｌugiｎEnumeｒaｔor　eｎｕmerａｔｏr;
ﻩｉf(!enｕｍeraｔor、GetPｌuginNaｍes(vstrPluｇinNames))
ﻩﻩrｅtｕrn　fａｌse；
fｏｒ（unsigned int　ｉ=0 ; ｉ<ｖstrＰluginNamｅs、sｉze(); i++)
{
ﻩtypedef iｎｔ　(*PLUGIＮ_CRＥATE)(IPrintPlugin**);
PＬUＧIN_ＣＲＥATE CrｅateＰｒoc;
ﻩIＰｒｉntPlugｉn ＊pPluｇiｎ　= NUＬL；
ﻩﻩvoid* hinｓtLiｂ ＝ dlopen（vstrＰｌuginNames[i］、c＿ｓtr(), RTLD_ＬAＺＹ);
ﻩiｆ(ｈinsｔLib !=　ＮULＬ）
ﻩﻩ{
ﻩCreａteＰｒｏc　= （ＰLUＧＩN_CREAＴE)dlsym(hｉnstLｉｂ, ＂CreateＯbj")；
ﻩ ｉf(NULL != CrｅaｔeProc）
ﻩ ﻩ{
ﻩ (CreatｅPrｏc）(&pＰlｕgin);
ﻩﻩ if（pPlugｉn != NULL)
ﻩﻩﻩﻩ{
ﻩ pPlugｉn-＞Ｈelｐ()；
ﻩ ﻩﻩ｝
ﻩ ｝
ﻩﻩﻩdlclose(hｉnｓｔＬiｂ);
ﻩﻩ}
ﻩ}
ｒｅtuｒn trｕe;
}
boｏl　CPluginCoｎtｒｏllｅr::IfＰｒocess(char ＊Fuｎctiｏｎ)//判断插件就是否存在
{
unsiｇneｄ int　ｉ;
ﻩｆor（i = 0; i < m＿vpPlugiｎ、size(); i++)
ﻩ{
ｉf(strcｍp(Funcｔion, m_ｖpPｌugin[ｉ]->GｅｔNａｍe(）） ＝= 0)
ﻩﻩ｛
ﻩﻩﻩbｒeak;
ﻩﻩ｝
ﻩ};
ﻩif(ｉ < m_vｐPｌugin、sｉzｅ())/／插件存在
｛
reｔuｒn　ｔrue;
ﻩ}
ﻩeｌｓｅ
ﻩ{
ﻩrｅtｕrn ｆalse；
}
}
booｌ ＣＰlｕginCｏｎtrolｌer：:ＰrocｅssFuncｔioｎ（char *Funcｔion,cｈar*Dｏcuｍenｔ）/／执行插件功能
{
ﻩfｏr(unsigneｄ ｉnt　i ＝ 0; i < m_ｖpPｌuｇin、sizｅ(）; i++)
{
ﻩ ｉf(strｃmp(Fｕnctiｏn, m_ｖpPlugｉn[ｉ]->GeｔNａme（）） == 0)
ﻩ｛
ﻩﻩｍ_ｖpＰｌugin[ｉ］->Fun(Doｃument);/／插件功能
ﻩﻩﻩｂｒeak;
ﻩ}
}
ｒeturn tｒue;
}
bool CPｌugiｎＣonｔrｏｌlｅr::UninitｉalｉzｅContrｏllｅr(）
{
ﻩfor(unｓｉgned　iｎt　i　=　０; i < m_vhForPlugｉn、sｉze();　i＋＋）
ﻩ{
ｄｌclｏsｅ(m_ｖhFoｒPｌugin[i]);
ﻩ}
ﻩreｔurｎ trｕe;
}
CＰlｕｇinContrｏｌｌer、h
#iｆndef CＰLＵGＩNCＯNＴROLＬER_H
#ｄefiｎe CPＬUGINCＯNTROLＬER＿H
#inｃlｕde ＜veｃtoｒ>
cｌass　IPｒintＰluｇｉn;
ｃｌass　CPluginＣontrｏller
｛
puｂlｉc:
CPluginContrｏlleｒ(ｖｏid);
virｔual ～CPlｕginＣoｎtroｌler(voiｄ);
ｂｏoｌ ＩnｉtialｉzeController(void);
bｏｏl ＵninｉtializeCoｎｔroller（voiｄ);
bool　PrｏceｓｓHeｌp(vｏｉd);
ﻩbool ProcｅｓsRｅｑuｅst(ｉnt FuｎctiｏnＩD）；
ｂool IfProcess(char *Fｕncｔiｏn)；
ﻩbooｌ PｒoｃｅssFｕncｔioｎ(char *Fuｎctiｏn,char *Documeｎt);
pｒivatｅ:
std::ｖeｃｔor<ｖｏｉd　*> m＿vｈFoｒＰlｕgiｎ；
ﻩstd::vector<ＩPrintPlugin*>　m_vｐPlugin;
};
#endif
CPｌｕｇiｎEnｕmerator、h
#ifndｅf　CPLUGINＥNUMERATOR_H
＃defiｎe CPLUGＩNENＵＭEＲＡTOR_H
#ｉｎclude　<veｃtor>
#inｃｌude <strｉnｇ>
ｕsｉnｇ nａmｅsｐace sｔd;
ｃlasｓ ＣＰlugiｎEnuｍｅrator
｛
publiｃ:
　 CPｌugｉnEnuｍｅrator（);
virｔuａl　～CＰlｕginＥn