SetEventData和GetEventData在WinXP的解决方案

原文地址::http://blog.csdn.net/chenyujing1234/article/details/8196164

转载自： http://blog.csdn.net/norains/article/details/5385429

 

//=====================================================================
//TITLE:
//    SetEventData和GetEventData在WinXP的解决方案
//AUTHOR:
//    norains
//DATE:
//    Tuesday 16-March-2010
//Environment:
//     WINDOWS XP
//=====================================================================

    如果你熟悉于WinCE开发，又经常通过SetEventData和GetEventData在进程间传递数据，那么当你想将代码移植到WinXP平台，将会遇到一个十分尴尬的问题：Win32 API根本就没有这两个函数！当然，如果你是采用.net框架，那么这不是问题，这里本文不做讨论。

 回到原点，我们来想想这两个函数的功能。我们可以这么认为，SetEventData是将DWORD数值和事件句柄相关联，而GetEventData则是将关联的数据取出。这些数据，是可以在不同的进程中共享的。

 

　　这个是不是和内存映射文件有几分类似？既然Win32 API没有这个函数，那么我们就手动来创建！
　　
　　由于事件句柄是与数值相关联地，从算法的简便性考虑，我们可以使用STL::map进行存储，这样可以大大降低我们的工作量。另一方面，因为我们在做映射文件时，有一些信息我们只能通过CreateEvent获取，故我们只能采用类的方式，将这几个函数重载。为描述简便，这个类我们声明为CMUF。
　　
　　先从头开始，我们看看重载的CreateEvent函数。其中的一些要点，我采用注释的方式列于代码中，方便于查看。

[cpp]  view plain copy

1. #include <iostream>  
2. #include <string>  
3. #include <map>   
4. #include <windows.h>  
5. #include<iostream>  
6. #include<sstream>  
7. #include <algorithm>  
8. using namespace std;  
9.   
10.   
11. class CMUF  
12. {  
13. private:  
14.     struct MemFile  
15.     {     
16.         HANDLE hFileMap;  
17.         HANDLE pMapBuf;  
18.         DWORD dwBufSize;  
19.         DWORD dwCount;  
20.     };  
21.   
22.     static std::map<HANDLE,string> ms_mpEventHandleToName;  
23.     static std::map<string,MemFile> ms_mpEventNameToFile;  
24.   
25.     BOOL InitMemFile(const string &strMapName,DWORD dwSize,MemFile &memFile);  
26.     BOOL CloseHandle(HANDLE hObject);  
27.     BOOL GetMemFile(HANDLE hEvent,MemFile &memFile);  
28.     BOOL SetEventData(HANDLE hEvent,DWORD dwData);  
29.     HANDLE CreateEvent(LPSECURITY_ATTRIBUTES lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName);  
30.     DWORD GetEventData(HANDLE hEvent);  
31.   
32. };  

 

[cpp]  view plain copy

1. OOL CMUF::InitMemFile(const string &strMapName,DWORD dwSize,MemFile &memFile)  
2. {  
3.   
4.     //创建映射文件  
5.     HANDLE hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,dwSize,strMapName.c_str());  
6.     if(hFileMap == NULL)  
7.     {  
8.         //ASSERT(hFileMap != NULL);  
9.         return FALSE;  
10.     }  
11.   
12.     //从映射文件句柄获得分配的内存空间  
13.     VOID *pMapBuf = MapViewOfFile(hFileMap,FILE_MAP_ALL_ACCESS,0,0,0);   
14.     if(pMapBuf == NULL)  
15.     {  
16.         //ASSERT(FALSE);  
17.         CloseHandle(hFileMap);  
18.         return FALSE;  
19.     }  
20.   
21.     //将内存中的数值设置为0  
22.     DWORD dwData = 0;  
23.     memcpy(pMapBuf,&dwData,dwSize);  
24.   
25.     //将数值保存到结构体中  
26.     memFile.hFileMap = hFileMap;  
27.     memFile.pMapBuf = pMapBuf;  
28.     memFile.dwBufSize = dwSize;  
29.     memFile.dwCount = 1;  
30.   
31.     return TRUE;  
32. }  
33.   
34.   
35. BOOL CMUF::CloseHandle(HANDLE hObject)  
36. {  
37.     if(hObject == NULL)  
38.     {  
39.         return FALSE;  
40.     }  
41.   
42.     //查找所关闭的句柄是否存在于记录里.   
43.     std::map<HANDLE,string>::iterator iterName = ms_mpEventHandleToName.find(hObject);  
44.     if(iterName != ms_mpEventHandleToName.end())  
45.     {  
46.   
47.         std::map<string,MemFile>::iterator iterFile = ms_mpEventNameToFile.find(iterName->second);  
48.         if(iterFile != ms_mpEventNameToFile.end())  
49.         {   
50.             //找到记录，数目减一  
51.             InterlockedDecrement(reinterpret_cast<LONG *>(&iterFile->second.dwCount));  
52.   
53.   
54.             if(iterFile->second.dwCount == 0)  
55.             {  
56.                 //如果记数为零，则删掉映射文件.  
57.   
58.                 UnmapViewOfFile(iterFile->second.pMapBuf);  
59.                 ::CloseHandle(iterFile->second.hFileMap);  
60.                 ms_mpEventNameToFile.erase(iterFile);  
61.             }  
62.         }  
63.   
64.         ms_mpEventHandleToName.erase(iterName);  
65.     }  
66.   
67.     //调用API函数进行真正的关闭。  
68.     return ::CloseHandle(hObject);  
69. }  
70.   
71.   
72. BOOL CMUF::GetMemFile(HANDLE hEvent,MemFile &memFile)  
73. {  
74.     if(hEvent == NULL)  
75.     {  
76.         return FALSE;  
77.     }  
78.   
79.     //根据句柄查找命名  
80.     std::map<HANDLE,string>::iterator iterEvent = ms_mpEventHandleToName.find(hEvent);  
81.     if(iterEvent == ms_mpEventHandleToName.end())  
82.     {  
83.         return FALSE;  
84.     }  
85.   
86.     //根据命名来查找映射文件信息  
87.     std::map<string,MemFile>::iterator iterMem = ms_mpEventNameToFile.find(iterEvent->second);  
88.     if(iterMem == ms_mpEventNameToFile.end())  
89.     {  
90.         return FALSE;  
91.     }  
92.   
93.     //将记录文件中的信息保存到输出变量缓存中。  
94.     memFile = iterMem->second;  
95.   
96.     return TRUE;  
97. }  
98.   
99.   
100. BOOL CMUF::SetEventData(HANDLE hEvent,DWORD dwData)  
101. {  
102.     MemFile memFile;  
103.     if(GetMemFile(hEvent,memFile) == FALSE || memFile.pMapBuf == NULL)  
104.     {  
105.         return FALSE;  
106.     }  
107.   
108.     //将数值拷贝到内存中  
109.     memcpy(memFile.pMapBuf,&dwData,memFile.dwBufSize);  
110.   
111.     return TRUE;  
112. }  
113.   
114. DWORD CMUF::GetEventData(HANDLE hEvent)  
115. {  
116.     MemFile memFile;  
117.     if(GetMemFile(hEvent,memFile) == FALSE || memFile.pMapBuf == NULL)  
118.     {  
119.         return 0;  
120.     }  
121.   
122.     //从内存中获取DWORD数据  
123.     DWORD dwVal = 0;  
124.     memcpy(&dwVal,memFile.pMapBuf,memFile.dwBufSize);  
125.   
126.     return dwVal;  
127. }  
128.   
129.   
130.   
131. HANDLE CMUF::CreateEvent(LPSECURITY_ATTRIBUTES lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName)  
132. {  
133.     BOOL bRes = FALSE;  
134.   
135.     //调用原生的API函数创建事件.  
136.     HANDLE hEvent = ::CreateEvent(lpEventAttributes,bManualReset,bInitialState,lpName);  
137.     if(hEvent == NULL)  
138.     {  
139.         //如果创建失败，跳转到EXIT  
140.         goto EXIT;  
141.     }  
142.   
143.     //先判断当前创建的这个事件是否已经被创建，以方便后续数据的处理。.  
144.     BOOL bIsExisting = (GetLastError() == ERROR_ALREADY_EXISTS);  
145.   
146.     if(bIsExisting == FALSE)  
147.     {    
148.         //这是一个新的的事件  
149.         string strMemFile;  
150.   
151.         //先判断这个类是否只是内部使用。所谓的内部使用，指的是没有名字的事件，除了通过句柄来进行使用以外，无法通过再次打开获得。  
152.         if(lpName != NULL)  
153.         {  
154.             //因为内存映射文件和事件名是同一个命名空间，所以这两者的名字不能相同。故我们要创建的内存映射文件名为：EVENT_前缀 + 事件名。  
155.             strMemFile = TEXT("EVENT_");  
156.             strMemFile += lpName;  
157.         }  
158.         else  
159.         {  
160.             //如果该事件为内部使用，那么也就意味着这内存映射文件也是内部使用。故采用程序句柄的名字+事件名的方式进行内存映射文件的名字确定。  
161.             ostringstream stream;   
162.             stream << GetModuleHandle(NULL) << TEXT("_") << hEvent;  
163.             strMemFile = stream.str();  
164.         }  
165.   
166.         //通过调用InitMemFile来创建内存映射文件  
167.         MemFile memFile;  
168.         if(InitMemFile(strMemFile,sizeof(DWORD),memFile) == FALSE)  
169.         {  
170.             goto EXIT;  
171.         }  
172.   
173.         //ms_mpEventHandleToName和ms_mpEventNameToFile是类的静态成员，用来存储事件和映射文件的对应关系。  
174.         if(lpName != NULL)  
175.         {  
176.             ms_mpEventHandleToName.insert(std::make_pair(hEvent,lpName));  
177.             ms_mpEventNameToFile.insert(std::make_pair(lpName,memFile));  
178.         }  
179.         else  
180.         {  
181.             //因为内部使用的事件没有名字，所以采用组合的名字作为标识  
182.             ms_mpEventHandleToName.insert(std::make_pair(hEvent,strMemFile));  
183.             ms_mpEventNameToFile.insert(std::make_pair(strMemFile,memFile));  
184.         }  
185.   
186.     }  
187.     else  
188.     {  
189.         //系统判断以该名字命名的事件已经被创建过，所以我们先搜索我们的数据库是否有相应的记录。  
190.         std::map<HANDLE,string>::iterator iterName = std::find_if(ms_mpEventHandleToName.begin(),ms_mpEventHandleToName.end(),Functor::value_equal<HANDLE,string>(lpName));  
191.         if(iterName == ms_mpEventHandleToName.end())  
192.         {  
193.             //ASSERT(FALSE);  
194.   
195.             goto EXIT;  
196.         }  
197.   
198.   
199.         std::map<string,MemFile>::iterator iterFile = ms_mpEventNameToFile.find(iterName->second);  
200.         if(iterFile == ms_mpEventNameToFile.end())  
201.         {  
202.             //ASSERT(FALSE);  
203.   
204.             goto EXIT;  
205.         }  
206.   
207.         //找到相应记录的话，则将记数加1  
208.         InterlockedIncrement(reinterpret_cast<LONG *>(&iterFile->second.dwCount));  
209.   
210.         //即使该名字命名的事件之前已经使用，但第二次创建时，句柄还是不同的，所以我们必须将其保存  
211.         ms_mpEventHandleToName.insert(std::make_pair(hEvent,lpName));  
212.     }  
213.   
214.     bRes = TRUE;  
215.   
216. EXIT:  
217.   
218.     if(bRes == FALSE)  
219.     {  
220.         CloseHandle(hEvent);  
221.     }  
222.   
223.     return hEvent;  
224.   
225. }  

 

 

二、ostringstream的使用

[cpp]  view plain copy

1. #include<iostream>  
2. #include<string>  
3. #include<sstream>  
4. using namespace std;  
5.   
6.   
7. int testStream()  
8. {     
9.     int i=10;     
10.     ostringstream ost;     
11.     ost << i;     
12.     string temp(ost.str());     
13.     cout << temp << endl;  
14.   
15.   
16.     return 0;  
17. }  

 

三、find_if

有时我们要在map、vector容器中查找符合条件的记录，map提供一个find的成员函数，但也仅限于查找关键字满足条件的记录，不支持值域的比较。如果我们要在值域中查找记录，该函数就无能无力了。而vector甚至连这样的成员函数都没有提供。所以一般情况下进行值域的查找，要么自己遍历数据，要么求助于STL的find_if函数。前种方法我们这里就不赘述了，只讲find_if函数。

1 -- find_if的STL定义

[cpp]  view plain copy

1. template <class InputIterator, class Predicate>   
2. InputIterator find_if(InputIterator first, InputIterator last,Predicate pred)   
3. {   
4.        while (first != last && !pred(*first)) ++first;   
5.        return first;   
6. }   

find_if是一个模板函数，接受两个数据类型：InputItearator迭代器，Predicate用于比较数值的函数或者函数对象（仿函数）。find_if对迭代器要求很低，只需要它支持自增操作即可。当前遍历到的记录符合条件与否，判断标准就是使得pred()为真。至此可能还有些不是很明了，下面举几个例子实际操练下的它的用法。

2 -- find_if在std::map查找时的应用

假如我们有个map对象是这么声明的：

[cpp]  view plain copy

1. std::map<int, std::string> my_map;  
2. my_map.insert(std::make_pair(10, "china"));  
3. my_map.insert(std::make_pair(20, "usa"));  
4. my_map.insert(std::make_pair(30, "english"));  
5. my_map.insert(std::make_pair(40, "hongkong"));  

插入值后我们想得到值为”english”的这条记录，要怎样写程序呢？下面是个范例参考下：

[cpp]  view plain copy

1. #include <map>   
2. #include <string>    
3. #include <algorithm>  
4.   
5. class map_finder   
6. {   
7. public:   
8.     map_finder(const std::string &cmp_string):m_s_cmp_string(cmp_string){}   
9.     bool operator ()(const std::map<int, std::string>::value_type &pair)   
10.     {   
11.         return pair.second == m_s_cmp_string;   
12.     }   
13. private:   
14.     const std::string &m_s_cmp_string;                       
15. };   
16.       
17. int main()   
18. {   
19.     std::map<int, std::string> my_map;   
20.     my_map.insert(std::make_pair(10, "china"));   
21.     my_map.insert(std::make_pair(20, "usa"));   
22.     my_map.insert(std::make_pair(30, "english"));   
23.     my_map.insert(std::make_pair(40, "hongkong"));       
24.            
25.     std::map<int, std::string>::iterator it = my_map.end();   
26.     it = std::find_if(my_map.begin(), my_map.end(), map_finder("english"));   
27.     if (it == my_map.end())   
28.         printf("not found/n");          
29.     else   
30.         printf("found key:%d value:%s/n", it->first, it->second.c_str());   
31.                
32.     return 0;           
33. }   

class map_finder即用于比较的函数对象，它的核心就是重载的()运算符。因为每个容器迭代器的*运算符得到的结果都是该容器的value_type值，所以该运算符的形参就是map迭代器指向的value_type类型的引用。而map的value_type到底是什么类型，就得看下STL的源代码是如何定义的。

[cpp]  view plain copy

1. template <class Key, class T, class Compare = less<Key>, class Alloc = alloc>  
2. class map  
3. {  
4. public:  
5. typedef Key key_type;  
6. typedef pair<const Key, T> value_type;  
7. ......  
8. };  

从上面的定义可以看出，map的value_type是std::pair<const Key, t>类型，它的first值就是关键字，second值保存map的值域。

3 -- find_if在std::vector的应用

vector的find_if用法与map的很相似，区别仅仅是二者的value_type不一样而已。我们看下vecotr对value_type的定义。

[cpp]  view plain copy

1. template <class T, class Alloc = alloc>  
2. class vector  
3. {  
4. public:  
5. typedef T value_type;  
6. typedef value_type* iterator;  
7. ......  
8. };  

可以看出vector的value_type就是容器的值类型，了解了这点，我们做个vector的find_if示范。

[cpp]  view plain copy

1. #include <vector>   
2. #include <string>   
3. #include <algorithm>  
4.      
5. struct value_t   
6. {   
7.     int a;   
8.     int b;   
9. };   
10.    
11. class vector_finder   
12. {   
13. public:   
14.     vector_finder(const int a):m_i_a(a){}   
15.     bool operator ()(const std::vector<struct value_t>::value_type &value)   
16.     {   
17.         return value.a == m_i_a;   
18.     }   
19. private:   
20.     int m_i_a;                       
21. };   
22.       
23. int main()   
24. {   
25.     std::vector<struct value_t> my_vector;   
26.     struct value_t my_value;   
27.          
28.     my_value.a = 11; my_value.b = 1000;   
29.     my_vector.push_back(my_value);   
30.         
31.     my_value.a = 12; my_value.b = 1000;   
32.     my_vector.push_back(my_value);   
33.       
34.     my_value.a = 13; my_value.b = 1000;   
35.     my_vector.push_back(my_value);   
36.      
37.     my_value.a = 14; my_value.b = 1000;   
38.     my_vector.push_back(my_value);   
39.           
40.     std::vector<struct value_t>::iterator it = my_vector.end();   
41.     it = std::find_if(my_vector.begin(), my_vector.end(), vector_finder(13));   
42.     if (it == my_vector.end())   
43.          printf("not found/n");          
44.     else   
45.         printf("found value.a:%d value.b:%d/n", it->a, it->b);   
46.            
47.     getchar();   
48.     return 0;           
49. }