Boost预报——通用几何库(GGL)

用共享内存作为匿名内存池

只要分配共享内存段的一部分作为缓存区，把信息复制进去，再把缓存区在共享内存中的偏移值发送给另外的进程，任务就完成啦！让我们看一个例子：

#include <boost/interprocess/managed_shared_memory.hpp>
#include <cstdlib> //std::system
#include <sstream>

int main (int argc, char *argv[])
{
using namespace boost::interprocess;
if(argc == 1){  //Parent process
      //Remove shared memory on construction and destruction
      struct shm_remove 
{
shm_remove() {  shared_memory_object::remove("MySharedMemory"); }
~shm_remove(){  shared_memory_object::remove("MySharedMemory"); }
} remover;

//Create a managed shared memory segment
      managed_shared_memory segment(create_only, "MySharedMemory", 65536);

//Allocate a portion of the segment (raw memory)
      std::size_t free_memory = segment.get_free_memory();
void * shptr = segment.allocate(1024/*bytes to allocate*/);

//Check invariant
      if(free_memory <= segment.get_free_memory())
return 1;

//An handle from the base address can identify any byte of the shared 
      //memory segment even if it is mapped in different base addresses
      managed_shared_memory::handle_t handle = segment.get_handle_from_address(shptr);
std::stringstream s;
s << argv[0] << " " << handle;
s << std::ends;
//Launch child process
      if(0 != std::system(s.str().c_str()))
return 1;
//Check memory has been freed
      if(free_memory != segment.get_free_memory())
return 1;
}
else{
//Open managed segment
      managed_shared_memory segment(open_only, "MySharedMemory");

//An handle from the base address can identify any byte of the shared 
      //memory segment even if it is mapped in different base addresses
      managed_shared_memory::handle_t handle = 0;

//Obtain handle value
      std::stringstream s; s << argv[1]; s >> handle;

//Get buffer local address from handle
      void *msg = segment.get_address_from_handle(handle);

//Deallocate previously allocated memory
      segment.deallocate(msg);
}
return 0;
}

建立命名共享内存对象

你可以在共享内存段中建立对象，赋于这个对象一个字符串名称，这样其它进程就可以找到、使用它们，以及当不再需要时删除它们。例：

#include <boost/interprocess/managed_shared_memory.hpp>
#include <cstdlib> //std::system
#include <cstddef>
#include <cassert>
#include <utility>

int main(int argc, char *argv[])
{
using namespace boost::interprocess;
typedef std::pair<double, int> MyType;

if(argc == 1){  //Parent process
      //Remove shared memory on construction and destruction
      struct shm_remove 
{
shm_remove() { shared_memory_object::remove("MySharedMemory"); }
~shm_remove(){ shared_memory_object::remove("MySharedMemory"); }
} remover;

//Construct managed shared memory
      managed_shared_memory segment(create_only, "MySharedMemory", 65536);

//Create an object of MyType initialized to {0.0, 0}
      MyType *instance = segment.construct<MyType>
("MyType instance")  //name of the object
         (0.0, 0);            //ctor first argument

//Create an array of 10 elements of MyType initialized to {0.0, 0}
      MyType *array = segment.construct<MyType>
("MyType array")     //name of the object
         [10]                 //number of elements
         (0.0, 0);            //Same two ctor arguments for all objects

//Create an array of 3 elements of MyType initializing each one
      //to a different value {0.0, 0}, {1.0, 1}, {2.0, 2}...
      float float_initializer[3] = { 0.0, 1.0, 2.0 };
int   int_initializer[3]   = { 0, 1, 2 };

MyType *array_it = segment.construct_it<MyType>
("MyType array from it")   //name of the object
         [3]                        //number of elements
         ( &float_initializer[0]    //Iterator for the 1st ctor argument
         , &int_initializer[0]);    //Iterator for the 2nd ctor argument

//Launch child process
      std::string s(argv[0]); s += " child ";
if(0 != std::system(s.c_str()))
return 1;


//Check child has destroyed all objects
      if(segment.find<MyType>("MyType array").first ||
segment.find<MyType>("MyType instance").first ||
segment.find<MyType>("MyType array from it").first)
return 1;
}
else{
//Open managed shared memory
      managed_shared_memory segment(open_only, "MySharedMemory");

std::pair<MyType*, std::size_t> res;

//Find the array
      res = segment.find<MyType> ("MyType array");   
//Length should be 10
      if(res.second != 10) return 1;

//Find the object
      res = segment.find<MyType> ("MyType instance");   
//Length should be 1
      if(res.second != 1) return 1;

//Find the array constructed from iterators
      res = segment.find<MyType> ("MyType array from it");
//Length should be 3
      if(res.second != 3) return 1;

//We're done, delete all the objects
      segment.destroy<MyType>("MyType array");
segment.destroy<MyType>("MyType instance");
segment.destroy<MyType>("MyType array from it");
}
return 0;
}

在共享内存中建立vector

Boost.Interprocess 允许在共享内存和内存映射文件中建立复杂对象。例如，我们可以在共享内存中构造类STL的容器。实现它我们只需要建立一个特定的（受控的 managed）共享内存段，声明一个Boost.Interprocess分配器，并且如同其它对象一样，在共享内存中构造vector。

允许在共享内存中应用复杂结构的类称为 boost::interprocess::managed_shared_memory，它很容易使用。不带参数地运行下面的例子：

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/containers/vector.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <string>
#include <cstdlib> //std::system

using namespace boost::interprocess;

//Define an STL compatible allocator of ints that allocates from the managed_shared_memory.
//This allocator will allow placing containers in the segment
typedef allocator<int, managed_shared_memory::segment_manager>  ShmemAllocator;

//Alias a vector that uses the previous STL-like allocator so that allocates
//its values from the segment
typedef vector<int, ShmemAllocator> MyVector;

//Main function. For parent process argc == 1, for child process argc == 2
int main(int argc, char *argv[])
{
if(argc == 1){ //Parent process
      //Remove shared memory on construction and destruction
      struct shm_remove 
{
shm_remove() { shared_memory_object::remove("MySharedMemory"); }
~shm_remove(){ shared_memory_object::remove("MySharedMemory"); }
} remover;

//Create a new segment with given name and size
      managed_shared_memory segment(create_only, "MySharedMemory", 65536);

//Initialize shared memory STL-compatible allocator
      const ShmemAllocator alloc_inst (segment.get_segment_manager());

//Construct a vector named "MyVector" in shared memory with argument alloc_inst
      MyVector *myvector = segment.construct<MyVector>("MyVector")(alloc_inst);

for(int i = 0; i < 100; ++i)  //Insert data in the vector
         myvector->push_back(i);

//Launch child process
      std::string s(argv[0]); s += " child ";
if(0 != std::system(s.c_str()))
return 1;

//Check child has destroyed the vector
      if(segment.find<MyVector>("MyVector").first)
return 1;
}
else{ //Child process
      //Open the managed segment
      managed_shared_memory segment(open_only, "MySharedMemory");  

//Find the vector using the c-string name
      MyVector *myvector = segment.find<MyVector>("MyVector").first;

//Use vector in reverse order
      std::sort(myvector->rbegin(), myvector->rend());

//When done, destroy the vector from the segment
      segment.destroy<MyVector>("MyVector");
}

return 0;
};

父进程建立一个特殊共享内存类，允许简单地构造多个与名称关联的复杂结构。之后父进程带参数地启动同一程序，子进程打开共享内存并使用vector和删除它。

在共享内存中建立map

就象vector一样，Boost.Interprocess可以在共享内存和内存映射文件中建立map。唯一的区别是，和标准关联容器一样，Boost.Interprocess的map在构造方法中传入分配器的同时还需要比较算子：

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/containers/map.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <functional>
#include <utility>

int main ()
{
using namespace boost::interprocess;

//Remove shared memory on construction and destruction
   struct shm_remove
{
shm_remove() { shared_memory_object::remove("MySharedMemory"); }
~shm_remove(){ shared_memory_object::remove("MySharedMemory"); }
} remover;

//Shared memory front-end that is able to construct objects
   //associated with a c-string. Erase previous shared memory with the name
   //to be used and create the memory segment at the specified address and initialize resources
   managed_shared_memory segment
(create_only 
,"MySharedMemory" //segment name
      ,65536);          //segment size in bytes

//Note that map<Key, MappedType>'s value_type is std::pair<const Key, MappedType>,
   //so the allocator must allocate that pair.
   typedef int    KeyType;
typedef float  MappedType;
typedef std::pair<const int, float> ValueType;

//Alias an STL compatible allocator of for the map.
   //This allocator will allow to place containers
   //in managed shared memory segments
   typedef allocator<ValueType, managed_shared_memory::segment_manager> 
ShmemAllocator;

//Alias a map of ints that uses the previous STL-like allocator.
   //Note that the third parameter argument is the ordering function
   //of the map, just like with std::map, used to compare the keys.
   typedef map<KeyType, MappedType, std::less<KeyType>, ShmemAllocator> MyMap;

//Initialize the shared memory STL-compatible allocator
   ShmemAllocator alloc_inst (segment.get_segment_manager());

//Construct a shared memory map.
   //Note that the first parameter is the comparison function,
   //and the second one the allocator.
   //This the same signature as std::map's constructor taking an allocator
   MyMap *mymap = 
segment.construct<MyMap>("MyMap")      //object name
                                 (std::less<int>() //first  ctor parameter
                                 ,alloc_inst);     //second ctor parameter

//Insert data in the map
   for(int i = 0; i < 100; ++i){
mymap->insert(std::pair<const int, float>(i, (float)i));
}
return 0;
}

更多高级例子，包括容器的容器，请参考容器的容器一节。