1. Use the LoadLibrary function to load the executable file Hand.exe.
2. Use the FindResource and LoadResource functions to locate and load the dialog box resource.
3. Use the LockResource function to retrieve a pointer to the dialog box resource data.
4. Use the BeginUpdateResource function to open an update handle to Foot.exe.
5. Use the UpdateResource function to copy the dialog box resource from Hand.exe to Foot.exe.
6. Use the EndUpdateResource function to complete the update.

   我手动的插入了一个二进制资源(RT_RCDATA)，不过发现FindResource这里总是返回NULL，
   最后问题终于解决了，要注意的地方主要有2点：
   1，可能是VC的BUG，加入资源后需要手动修改 .rc文件，加入
 /////////////////////////////////////////////////////////////////////////////
//
// RCDATA
//

IDR_RCDATA2           RCDATA           "res\\rcdata1.bin"

  否则.rc文件里只有这句：
/////////////////////////////////////////////////////////////////////////////
//
// RCDATA
//

2，这里指定了RCDATA 放在 res\\rcdata1.bin里，如果你的rcdata1.bin的内容是空的，也会FindResource失败。

还有，就是如果你想修改正在执行的程序的资源，恐怕用UpdateResource是会失败的，即使调用EndUpdateResource也不行！
只能修改未执行的exe，如果有朋友知道什么解决办法可以修改正在执行中程序的资源，欢迎告知!

下面是MSDN上关于如何修改exe资源的例子： 从hand.exe 中读取资源并复制到 foot.exe。

 1 HRSRC hResLoad;      //  handle to loaded resource 
 2 HANDLE hExe;         //  handle to existing .EXE file 
 3 HRSRC hRes;          //  handle/ptr. to res. info. in hExe 
 4 HANDLE hUpdateRes;   //  update resource handle 
 5 char   * lpResLock;     //  pointer to resource data 
 6 BOOL result; 
 7 //  Load the .EXE file that contains the dialog box you want to copy. 
 8 hExe  =  LoadLibrary( " hand.exe " ); 
 9 if  (hExe  ==  NULL) 
10 { 
11     ErrorHandler( " Could not load exe. " ); 
12 }  
13  
14 //  Locate the dialog box resource in the .EXE file. 
15 hRes  =  FindResource(hExe,  " AboutBox " , RT_DIALOG); 
16 if  (hRes  ==  NULL) 
17 { 
18     ErrorHandler( " Could not locate dialog box. " ); 
19 }  
20  
21 //  Load the dialog box into global memory. 
22 hResLoad  =  LoadResource(hExe, hRes); 
23 if  (hResLoad  ==  NULL) 
24 { 
25     ErrorHandler( " Could not load dialog box. " ); 
26 }  
27  
28 //  Lock the dialog box into global memory. 
29 lpResLock  =  LockResource(hResLoad); 
30 if  (lpResLock  ==  NULL) 
31 { 
32     ErrorHandler( " Could not lock dialog box. " ); 
33 }  
34  
35 //  Open the file to which you want to add the dialog box resource. 
36 hUpdateRes  =  BeginUpdateResource( " foot.exe " , FALSE); 
37 if  (hUpdateRes  ==  NULL) 
38 { 
39     ErrorHandler( " Could not open file for writing. " ); 
40 }  
41  
42 //  Add the dialog box resource to the update list. 
43 result  =  UpdateResource(hUpdateRes,        //  update resource handle 
44      RT_DIALOG,                    //  change dialog box resource 
45       " AboutBox " ,                   //  dialog box name 
46      MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),   //  neutral language
47      lpResLock,                    //  ptr to resource info 
48      SizeofResource(hExe, hRes));  //  size of resource info. 
49 if  (result  ==  FALSE) 
50 { 
51     ErrorHandler( " Could not add resource. " ); 
52 }  
53  
54 //  Write changes to FOOT.EXE and then close it. 
55 if  ( ! EndUpdateResource(hUpdateRes, FALSE)) 
56 { 
57     ErrorHandler( " Could not write changes to file. " ); 
58 }  
59  
60 //  Clean up. 
61 if  ( ! FreeLibrary(hExe)) 
62 { 
63     ErrorHandler( " Could not free executable. " ); 
64 }  

In Win32, memory can be shared amongst several processes on the same machine using file mapping.  Mechanical devices such as hard drives have very high access latencies and low transfer rates as compared to electrical devices such as memory.  Operating systems alleviate these discrepancies by using buffering techniques.  A buffer is nothing more than memory allocation that is used to hold information from the slower mechanical device.  The buffer caches all the data that is read from or written to the disk.   For example, a hundred bytes written to a file would be buffered with out actual writing to the file containing device.  If the same 100 bytes need to be read, they would be read from the buffer.  Reading from the buffer is far faster than, if the data was written to the disk, followed by a read of the disk drive.  If several processes need access to the same file at the same time, they all access it through the same buffer(to keep consistent reads and writes).  File mapping in win32 offers direct access to the user for this file buffer.  The file buffer space is mapped to the local process space of each of the processes.  Since memory is broken into pages, the buffer space is always rounded up to the next page size.

The CreateFileMapping function is used to create a file-mapping kernel object which is used to refer to the file buffer of a given file.  The function takes a handle to a file object as an argument.  File mapping kernel objects can either anonymous or named.  The CreateFileMapping function takes a name argument.  If the argument is NULL, than the file mapping object is anonymous.   If the argument is a non-NULL string, then the object is named.  If the object already exists, a reference to the existing file mapping object is returned. The OpenFileMapping function can be used to get access to the a named file mapping object.  The function MapViewOfFile is used to map the file buffer to the process space of the current process. It takes an argument of a handle to the file mapping object.  The return value of the function is a pointer to the beginning of the buffer in the processes own memory space.  If the process modifies memory locations in the buffer, when the file is finally closed and buffers flushed(written) to the disk, the file would be changed.  The function UnmapViewOfFile is used to remove the buffer from the current processes memory space.  The CloseHandle function can be used to close the a handle to the file-mapping kernel object.

If the CreateFileMapping function is passed a value 0xFFFFFFFF as an argument for the file handle(file whose buffer is going to be shared), the function will return a handle to a buffer that is not associated with any file.  This buffer can be used amongst several processes as shared memory.  Using OpenFileMapping is more difficult, due to writing code for creation and opening of file mapping kernels, as compared to that of just using CreateFileMapping function alone.

The CreateFileMapping takes arguments to specify the memory access rights.  If a file is opened for reading only and the handle is passed to CreateFileMapping, the associated buffer can only be read from.  It cannot be written to.  If an attempt is made to write to that memory, the process will receive a protection fault.   If a file is opened for both reading and writing, then the file mapping object can be created with a subset of the permissions.  The file mapping object can be made for reading and writing or only reading.

Using shared memory in conjunction with either interlocked functions or critical section objects is very efficient as compared to creating and using kernel objects such as semaphores, mutexes, and event objects.

The next program demonstrates the conversion of a file to upper case by first creating a file mapping for the ReadMe.txt text file.

The next program demonstrates access to shared memory.  Two processes access a ten buffers.  Each buffer has a maximum size of 100 bytes.  The first process is writer process that write information to the buffers in ascending order.  The second process is a reader that reads the buffers.  This is the standard reader-writer problem found in operating system courses.