Shared memory - matrix mapping - c++

Question

I'm currently working on a Bomberman game project where there should be a Server, which has a bidimensional matrix, and 1 or more Clients.
The way that I think it should be done is by using shared memory between process, where the clients and "enemies" access to get the information about the Table Map(Matrix) and work with that.
The problem is that I don't know how to map a pointer to my Map object(Matrix) so the other processes can grab that information.
I've got this function from MSDN but I only explain to a string:
//Server.cpp
//object creation (Matrix)
Mapa M(height, width);
hMapFile = CreateFileMapping(
INVALID_HANDLE_VALUE, // use paging file
NULL, // default security
PAGE_READWRITE, // read/write access
0, // maximum object size(high-order DWORD)
BUF_SIZE, // maximum object size (low-order DWORD)
szName); // name of mapping object
if (hMapFile == NULL)
{
_tprintf(TEXT("Could not create file mapping object (%d).\n"),
GetLastError());
return 1;
}
**HANDLE hMapFile = &M; // will this work?**
pBuf = (LPTSTR) MapViewOfFile(hMapFile, // <- How can I pass the object here?
FILE_MAP_ALL_ACCESS, // read/write permission
0,
0,
BUF_SIZE);
if (pBuf == NULL)
{
_tprintf(TEXT("Could not map view of file (%d).\n"),
GetLastError());
CloseHandle(hMapFile);
return 1;
}
Please how can I map a pointer to an object or even to an object so the other processes can access?
Regards,
RC

Answer 1

To use a mapping file your server code should look something like the following. Note that I do not check for any errors to keep the posted code simple (always check for errors!).
/* server */
HANDLE hFile;
HANDLE hMapFile;
hFile = CreateFile("test.dat",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
hMapFile = CreateFileMapping(hFile,
NULL,
PAGE_READWRITE,
0,
1024 * 1024,
"test.mapping"); // "mapping file name" of "test.dat"
/* keep server process running and do not close hFile or hMapFile */
And your client should look something like this:
/* client */
HANDLE hMapFile;
char *pFile; // note: you can use any type of pointer here!
hMapFile = OpenFileMapping(FILE_MAP_READ | FILE_MAP_WRITE,
FALSE,
"test.mapping"); // same name as within CreateFileMapping(..)
if (hMapFile != NULL)
{
pFile = MapViewOfFile(hMapFile,
FILE_MAP_ALL_ACCESS,
0,
0,
1024 * 1024);
/* read pFile */
printf(pFile);
/* write pFile */
wsprintf(pFile, "Hallo?"); // <-- writes to test.dat!!
}
As noted before this design will have some drawbacks if used for a server/client architecture. I recommend using a TCP/IP server/client which is no more difficult to implement than named pipes. A good place to start would be Running the Winsock Client and Server Code Sample but there are numerous other examples on the web...
If using TCP/IP your application will look something like this:
/* server */
// create listener socket
// while running
// accept new client(s)
// receive data from clients (if any data was received)
// react on data: (client sent 0x01 -> send matrix, ...)
/* client */
// create socket and connect to server
// send 0x01 command to obtain matrix
// receive response from server (= get matrix)
// do whatever your client does...
Note that the 0x01 is a simple command byte to tell the server what to do. You're completely free on how to tell the server what to do. You can as well implement a string based command interface (e.g. client sends "get_matrix" instead of 0x01)...