C/C++: Shared Memory，不同 Process 資料交換的方式

#include <sys/mman.h>
int shm_open(const char *name, int oflag, mode_t mode);
int shm_unlink(const char *name);

#include <sys/mman.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

const char* SM_NAME = "/SHARED_MEMORY_TEST";

// 建立 POSIX shared memory 物件
int fd = shm_open(
  SM_NAME,  // shared memory 物件名稱
  O_CREAT | O_RDWR,  // 自動創建及讀寫權限
  0777);  // 檔案權限

// 檢查是否建立成功
if(fd < 0){
  printf("shm_open failed!, %s\n", strerror(errno));
  return 1;
}

// 刪除 shared memory 物件
if(shm_unlink(SM_NAME) != 0){
  printf("shm_unlink failed!, %s\n", strerror(errno));
  return 1;
}

#include <unistd.h>
int truncate(const char *path, off_t length);
int ftruncate(int fildes, off_t length);

#include <unistd.h>
#include <errno.h>
#include <string.h>

// 調整物件大小
int r = ftruncate(fd, sizeof(int));

// 檢查是否調整成功
if(r < 0){
  printf("ftruncate failed!, %s\n", strerror(errno));
  return 1;
}

#include <sys/mman.h>
void* mmap(void* addr, size_t length, int prot, int flags,
            int fd, off_t offset);
int munmap(void* addr, size_t length);

#include <sys/mman.h>
#include <errno.h>
#include <string.h>

void *buf = mmap(
  NULL,  // 讓 OS 自動決定地址
  sizeof(int),  // map 的大小
  PROT_READ | PROT_WRITE,  // pages 可讀可寫
  MAP_SHARED,  // 將所有修改與其他 process 共享
  fd,  // file descriptor
  0);  // 不要做位移，從 fd 的頭開始

// 檢查是否映射成功
if(buf == MAP_FAILED){
  printf("mmap failed!, %s\n", strerror(errno));
  return 1;
}

// 刪除映射
if(munmap(buf, sizeof(int)) != 0){
  printf("munmap failed!, %s\n", strerror(errno));
  return 1;
}

#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>

int main(){

  const char* shared_memory_name = "SHARED_MEMORY_TEST";
  size_t bufSize = sizeof(int);

  // 創建 shared memory object
  int fd = shm_open(
    shared_memory_name,
    O_CREAT | O_RDWR,
    0777);
  if(fd < 0){
    printf("shm_open failed!, %s\n", strerror(errno));
    return 1;
  }

  // 調整大小
  int r = ftruncate(fd, bufSize);
  if(r < 0){
    printf("ftruncate failed!, %s\n", strerror(errno));
    return 1;
  }
  
  // memory mapping
  void *buf = mmap(
    NULL,
    sizeof(int),
    PROT_READ | PROT_WRITE,
    MAP_SHARED,
    fd,
    0);

  // 檢查是否映射成功
  if(buf == MAP_FAILED){
    printf("mmap failed!, %s\n", strerror(errno));
    return 1;
  }
  
  int* integer = ((int*)buf);
  *integer = 1;

  // 刪除映射
  if(munmap(buf, sizeof(int)) != 0){
    printf("munmap failed!, %s\n", strerror(errno));
    return 1;
  }

  // 刪除 shared memory object
  if(shm_unlink(shared_memory_name) != 0){
    printf("shm_unlink failed!, %s\n", strerror(errno));
    return 1;
  }
  
  return 0;
}

gcc test.cpp -o test.exe -lrt

HANDLE CreateFileMapping(
  [in]           HANDLE                hFile,
  [in, optional] LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
  [in]           DWORD                 flProtect,
  [in]           DWORD                 dwMaximumSizeHigh,
  [in]           DWORD                 dwMaximumSizeLow,
  [in, optional] LPCSTR                lpName
);

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>

TCHAR szName[] = TEXT("Local\\TESTTESTTEST");

HANDLE hMapFile;
LPCTSTR pBuf;

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 OpenFileMappingA(
  [in] DWORD  dwDesiredAccess,
  [in] BOOL   bInheritHandle,
  [in] LPCSTR lpName
);

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>

TCHAR szName[] = TEXT("Global\\TESTTESTTEST");

HANDLE hMapFile;
LPCTSTR pBuf;

hMapFile = OpenFileMapping(
            FILE_MAP_ALL_ACCESS,   // read/write access
            FALSE,                 // do not inherit the name
            szName);               // name of mapping object

if (hMapFile == NULL){
  _tprintf(TEXT("Could not open file mapping object (%d).\n"),
          GetLastError());
  return 1;
}

LPVOID MapViewOfFile(
  [in] HANDLE hFileMappingObject,
  [in] DWORD  dwDesiredAccess,
  [in] DWORD  dwFileOffsetHigh,
  [in] DWORD  dwFileOffsetLow,
  [in] SIZE_T dwNumberOfBytesToMap
);
BOOL UnmapViewOfFile(
  [in] LPCVOID lpBaseAddress
);

pBuf = (LPTSTR) MapViewOfFile(hMapFile,   // handle to map object
    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());
  // 記得關掉先前創建的 file mapping object
  CloseHandle(hMapFile);
  return 1;
}

UnmapViewOfFile(pBuf);