[C++知识库]C/C++ boost 库实现共享内存（share memory）的读写操作【代码实例】

文档声明：
以下资料均属于本人在学习过程中产出的学习笔记，如果错误或者遗漏之处，请多多指正。并且该文档在后期会随着学习的深入不断补充完善。感谢各位的参考查看。

---

笔记资料仅供学习交流使用，转载请标明出处，谢谢配合。
如果存在相关知识点的遗漏，可以在评论区留言，看到后将在第一时间更新。
作者：Aliven888

简单读写操作

// boostDemo.h 

#pragma once
#include <iostream>
#include <string>
#include <boost\interprocess\shared_memory_object.hpp>
#include <boost\interprocess\mapped_region.hpp>
using namespace boost::interprocess;
using namespace std;

enum ALIVEN_ERR_CODE
{
	ALIVEN_RETURN_OK = 0,				//返回操作成功
	ALIVEN_RETURN_INIT_PTR_ERR = 1,		//初始化指针失败  
	ALIVEN_RETURN_PARAM_EMPTY = 2,		//参数为空（参数不合法）
	ALIVEN_RETURN_OPEN_FILE_ERR = 3,	//打开文件失败
	ALIVEN_RETURN_FILE_NOT_EXIST = 4,	//指定文件不存在
	ALIVEN_RETURN_BUILD_FILE_ERR = 5,	//创建文件失败
	ALIVEN_RETURN_CURR_APTH_IS_DIR = 6,	//当前路径是目录（不是文件）
	ALIVEN_SHARE_MEMORY_CREATE_ERR = 30,//共享内存创建失败
	ALIVEN_SHARE_MEMORY_NOT_EXIST = 31, //共享内存不存在
	ALIVEN_SHARE_MEMORY_CLEAN_ERR = 32, //共享内存清理失败
	ALIVEN_RETURN_UNKNOWN_ERR           //返回操作失败，原因未知
};

int writeCacheToMemory();
int readCacheFromMemory();
int cleanShareMemoryCache();

// boostDemo.cpp

#include "boostDemo.h"

//写入共享内存
int writeCacheToMemory()
{
	int iRet = ALIVEN_RETURN_OK;

	try
	{
		//1.创建之前，先移除，保证其在系统中是不存在的
		shared_memory_object::remove("Aliven_ShareMemory");

		//2.创建
		shared_memory_object shm(create_only, "Aliven_ShareMemory", read_write);

		//3. 设置共享内存大小
		shm.truncate(1024);

		//4. 映射共享内存片段
		mapped_region region(shm, read_write);

		//5. 初始化共享内存空间
		std::memset(region.get_address(), 0, region.get_size());

		//6. 向共享内存中写入数据
		std::string *str = static_cast<std::string *>(region.get_address());
		*str = "hello world.";

		std::cout << shm.get_name() << " wirte suc." << std::endl;
	}
	catch (const std::exception&)
	{
		iRet = ALIVEN_SHARE_MEMORY_CREATE_ERR;
	}

	return iRet;
}

//从共享内存中读取
int readCacheFromMemory()
{
	int iRet = ALIVEN_RETURN_OK;

	try
	{
		//1. 读取共享内存
		shared_memory_object shm(open_only, "Aliven_ShareMemory", read_only);

		//2. 映射共享内存
		mapped_region region(shm, read_only);

		//3. 获取数据
		std::string *str = static_cast<std::string *>(region.get_address());

		//5. 打印数据
		std::cout << "read " << shm.get_name() << " content : " << *str << std::endl;
	}
	catch (const std::exception&)
	{
		iRet = ALIVEN_SHARE_MEMORY_NOT_EXIST;
	}
	
	return iRet;
}

//清除共享内存
int cleanShareMemoryCache()
{
	int iRet = ALIVEN_RETURN_OK;
	if (!shared_memory_object::remove("Aliven_ShareMemory"))
	{
		iRet = ALIVEN_SHARE_MEMORY_CLEAN_ERR;
	}
	return iRet;
}

线程、进程间读写操作

? 共享内存在线程或者进程间使用时，因为其没有任何同步或者互斥机制，所以我们需要使用 信号量 来实现对共享内存的读写同步操作。

? 因为进程间 与 线程间的实现类似，这里仅举例 多线程的。

// boostDemo.h 

#pragma once
#include <iostream>
#include <string>
#include <boost\interprocess\shared_memory_object.hpp>
#include <boost\interprocess\mapped_region.hpp>
using namespace boost::interprocess;
using namespace std;

enum ALIVEN_ERR_CODE
{
	ALIVEN_RETURN_OK = 0,				//返回操作成功
	ALIVEN_RETURN_INIT_PTR_ERR = 1,		//初始化指针失败  
	ALIVEN_RETURN_PARAM_EMPTY = 2,		//参数为空（参数不合法）
	ALIVEN_RETURN_OPEN_FILE_ERR = 3,	//打开文件失败
	ALIVEN_RETURN_FILE_NOT_EXIST = 4,	//指定文件不存在
	ALIVEN_RETURN_BUILD_FILE_ERR = 5,	//创建文件失败
	ALIVEN_RETURN_CURR_APTH_IS_DIR = 6,	//当前路径是目录（不是文件）
	ALIVEN_SHARE_MEMORY_CREATE_ERR = 30,//共享内存创建失败
	ALIVEN_SHARE_MEMORY_NOT_EXIST = 31, //共享内存不存在
	ALIVEN_SHARE_MEMORY_CLEAN_ERR = 32, //共享内存清理失败
	ALIVEN_RETURN_UNKNOWN_ERR           //返回操作失败，原因未知
};

#define SHM_BUFFER 1024

//数据类型
typedef struct stu_ShmData 
{
	int iSignal;  //信号量  0-可读  1-可写
	char szBuffer[SHM_BUFFER];  //数据空间
}STU_SHM_DATA;

int writeCacheToMemoryT();
int readCacheFromMemoryT();

// boostDemo.cpp

#include "boostDemo.h"

int writeCacheToMemoryT()
{
	int iRet = ALIVEN_RETURN_OK;
	
	try
	{
		shared_memory_object::remove("Aliven_ShareMemoryT");
		shared_memory_object shm(create_only, "Aliven_ShareMemoryT", read_write);
		shm.truncate(sizeof(STU_SHM_DATA));
		mapped_region region(shm, read_write);
		std::memset(region.get_address(), 0, region.get_size());
		STU_SHM_DATA *st = static_cast<STU_SHM_DATA *>(region.get_address());

		st->iSignal = 1;
		int iCount = 3;
		while (iCount > 0)
		{
			if (st->iSignal != 0)
			{
				memcpy_s(st->szBuffer, SHM_BUFFER, "12345", 6);
				st->iSignal = 0;
				std::cout << "write content to shm - " << iCount << std::endl;
				--iCount;
			} 
			else
			{
				Sleep(10);
			}
		}

	}
	catch (const std::exception&)
	{
		iRet = ALIVEN_SHARE_MEMORY_CREATE_ERR;
	}

	return iRet;
}
int readCacheFromMemoryT()
{
	int iRet = ALIVEN_RETURN_OK;
	
	try
	{
		shared_memory_object shm(open_only, "Aliven_ShareMemoryT", read_write);
		mapped_region region(shm, read_write);

		STU_SHM_DATA *st = static_cast<STU_SHM_DATA *>(region.get_address());

		st->iSignal = 0;
		int iCount = 3;
		while (iCount > 0)
		{
			if (st->iSignal != 1)
			{
				std::cout << "current read " << iCount << " txt is : " << st->szBuffer << std::endl;
				st->iSignal = 1;
				--iCount;
			} 
			else
			{
				Sleep(10);
			}
		}
	}
	catch (const std::exception&)
	{
		iRet = ALIVEN_SHARE_MEMORY_CREATE_ERR;
	}

	return iRet;
}

#include "stdafx.h"
#include <thread>
#include <mutex>

int main(int argc, char *argv[])
{
	//多线程
	std::thread th1(writeCacheToMemoryT);
	std::thread th2(readCacheFromMemoryT);

	th1.detach();
	th2.detach();

	system("pause");
	return 0;
}