Карта сайта Kansoftware
НОВОСТИУСЛУГИРЕШЕНИЯКОНТАКТЫ
Разработка программного обеспечения

Indexes and Reference

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Chapter 16. Boost.Interprocess

Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

PrevUpHomeNext
Indexes
Boost.Interprocess Header Reference
Class Index
Typedef Index
Function Index

Class Index

ABCDEFILMNOPRSTUWX

A
B
C
D
E
F
I
L
M
N
O
P
R
S
T
U
W
X

Typedef Index

ABCDEFIKMNOPRSTUVW

A
B
C
D
E
F
I
K
M
N
O
P
R
S
T
U
V
W

Function Index

0ABCDEFGIKLMNOPRSTUVWZ

0
A
B
C
D
E
F
G
I
K
L
M
N
O
P
R
S

  • swap_vector

    • T
    U
    V
    W
    X
    Z

    Boost.Interprocess Header Reference

    Header <boost/interprocess/allocators/adaptive_pool.hpp>
    Header <boost/interprocess/allocators/allocator.hpp>
    Header <boost/interprocess/allocators/cached_adaptive_pool.hpp>
    Header <boost/interprocess/allocators/cached_node_allocator.hpp>
    Header <boost/interprocess/allocators/node_allocator.hpp>
    Header <boost/interprocess/allocators/private_adaptive_pool.hpp>
    Header <boost/interprocess/allocators/private_node_allocator.hpp>
    Header <boost/interprocess/anonymous_shared_memory.hpp>
    Header <boost/interprocess/containers/allocation_type.hpp>
    Header <boost/interprocess/containers/deque.hpp>
    Header <boost/interprocess/containers/flat_map.hpp>
    Header <boost/interprocess/containers/flat_set.hpp>
    Header <boost/interprocess/containers/list.hpp>
    Header <boost/interprocess/containers/map.hpp>
    Header <boost/interprocess/containers/pair.hpp>
    Header <boost/interprocess/containers/set.hpp>
    Header <boost/interprocess/containers/slist.hpp>
    Header <boost/interprocess/containers/stable_vector.hpp>
    Header <boost/interprocess/containers/string.hpp>
    Header <boost/interprocess/containers/vector.hpp>
    Header <boost/interprocess/containers/version_type.hpp>
    Header <boost/interprocess/creation_tags.hpp>
    Header <boost/interprocess/errors.hpp>
    Header <boost/interprocess/exceptions.hpp>
    Header <boost/interprocess/file_mapping.hpp>
    Header <boost/interprocess/indexes/flat_map_index.hpp>
    Header <boost/interprocess/indexes/iset_index.hpp>
    Header <boost/interprocess/indexes/iunordered_set_index.hpp>
    Header <boost/interprocess/indexes/map_index.hpp>
    Header <boost/interprocess/indexes/null_index.hpp>
    Header <boost/interprocess/indexes/unordered_map_index.hpp>
    Header <boost/interprocess/interprocess_fwd.hpp>
    Header <boost/interprocess/ipc/message_queue.hpp>
    Header <boost/interprocess/managed_external_buffer.hpp>
    Header <boost/interprocess/managed_heap_memory.hpp>
    Header <boost/interprocess/managed_mapped_file.hpp>
    Header <boost/interprocess/managed_shared_memory.hpp>
    Header <boost/interprocess/managed_windows_shared_memory.hpp>
    Header <boost/interprocess/managed_xsi_shared_memory.hpp>
    Header <boost/interprocess/mapped_region.hpp>
    Header <boost/interprocess/mem_algo/rbtree_best_fit.hpp>
    Header <boost/interprocess/mem_algo/simple_seq_fit.hpp>
    Header <boost/interprocess/offset_ptr.hpp>
    Header <boost/interprocess/permissions.hpp>
    Header <boost/interprocess/segment_manager.hpp>
    Header <boost/interprocess/shared_memory_object.hpp>
    Header <boost/interprocess/smart_ptr/deleter.hpp>
    Header <boost/interprocess/smart_ptr/enable_shared_from_this.hpp>
    Header <boost/interprocess/smart_ptr/intrusive_ptr.hpp>
    Header <boost/interprocess/smart_ptr/scoped_ptr.hpp>
    Header <boost/interprocess/smart_ptr/shared_ptr.hpp>
    Header <boost/interprocess/smart_ptr/unique_ptr.hpp>
    Header <boost/interprocess/smart_ptr/weak_ptr.hpp>
    Header <boost/interprocess/streams/bufferstream.hpp>
    Header <boost/interprocess/streams/vectorstream.hpp>
    Header <boost/interprocess/sync/file_lock.hpp>
    Header <boost/interprocess/sync/interprocess_condition.hpp>
    Header <boost/interprocess/sync/interprocess_condition_any.hpp>
    Header <boost/interprocess/sync/interprocess_mutex.hpp>
    Header <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
    Header <boost/interprocess/sync/interprocess_semaphore.hpp>
    Header <boost/interprocess/sync/interprocess_sharable_mutex.hpp>
    Header <boost/interprocess/sync/interprocess_upgradable_mutex.hpp>
    Header <boost/interprocess/sync/lock_options.hpp>
    Header <boost/interprocess/sync/mutex_family.hpp>
    Header <boost/interprocess/sync/named_condition.hpp>
    Header <boost/interprocess/sync/named_condition_any.hpp>
    Header <boost/interprocess/sync/named_mutex.hpp>
    Header <boost/interprocess/sync/named_recursive_mutex.hpp>
    Header <boost/interprocess/sync/named_semaphore.hpp>
    Header <boost/interprocess/sync/named_sharable_mutex.hpp>
    Header <boost/interprocess/sync/named_upgradable_mutex.hpp>
    Header <boost/interprocess/sync/null_mutex.hpp>
    Header <boost/interprocess/sync/scoped_lock.hpp>
    Header <boost/interprocess/sync/sharable_lock.hpp>
    Header <boost/interprocess/sync/upgradable_lock.hpp>
    Header <boost/interprocess/windows_shared_memory.hpp>
    Header <boost/interprocess/xsi_key.hpp>
    Header <boost/interprocess/xsi_shared_memory.hpp>

    Описывает адаптивный_пул объединенной совместной памяти STL совместимый распределитель

    namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager, std::size_t NodesPerBlock, 
             std::size_t MaxFreeBlocks, unsigned char OverheadPercent> 
      class adaptive_pool;
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             unsigned char OP> 
      bool operator==(const adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const adaptive_pool< T, S, NodesPerBlock, F, OP > &);
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             unsigned char OP> 
      bool operator!=(const adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const adaptive_pool< T, S, NodesPerBlock, F, OP > &);
  }
}

    Описывает распределитель, который выделяет части буфера памяти фиксированного размера (общая память, отображенный файл).

    namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager> class allocator;
    template<typename T, typename SegmentManager> 
      bool operator==(const allocator< T, SegmentManager > &, 
                      const allocator< T, SegmentManager > &);
    template<typename T, typename SegmentManager> 
      bool operator!=(const allocator< T, SegmentManager > &, 
                      const allocator< T, SegmentManager > &);
  }
}

    Описывает cached_adaptive_pool объединенную общую память STL совместимый распределитель

    namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager, std::size_t NodesPerBlock, 
             std::size_t MaxFreeBlocks, unsigned char OverheadPercent> 
      class cached_adaptive_pool;
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             std::size_t OP> 
      bool operator==(const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             std::size_t OP> 
      bool operator!=(const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
  }
}

    Описывает кэшированный_cached_node_allocator объединенную общую память STL совместимый распределитель

    namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
      class cached_node_allocator;
    template<typename T, typename S, std::size_t NPC> 
      bool operator==(const cached_node_allocator< T, S, NPC > &, 
                      const cached_node_allocator< T, S, NPC > &);
    template<typename T, typename S, std::size_t NPC> 
      bool operator!=(const cached_node_allocator< T, S, NPC > &, 
                      const cached_node_allocator< T, S, NPC > &);
  }
}

    Описание node_allocator pooled shared memory STL

    namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
      class node_allocator;
    template<typename T, typename S, std::size_t NPC> 
      bool operator==(const node_allocator< T, S, NPC > &, 
                      const node_allocator< T, S, NPC > &);
    template<typename T, typename S, std::size_t NPC> 
      bool operator!=(const node_allocator< T, S, NPC > &, 
                      const node_allocator< T, S, NPC > &);
  }
}

    Описывает private_adaptive_pool_base Объединенная общая память STL совместимый распределитель

    namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager, std::size_t NodesPerBlock, 
             std::size_t MaxFreeBlocks, unsigned char OverheadPercent> 
      class private_adaptive_pool;
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             unsigned char OP> 
      bool operator==(const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             unsigned char OP> 
      bool operator!=(const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
  }
}

    Описывает частный_node_allocator_base Объединенная общая память STL совместимый распределитель

    namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
      class private_node_allocator;
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             unsigned char OP> 
      bool operator==(const private_node_allocator< T, S, NodesPerBlock, F, OP > &, 
                      const private_node_allocator< T, S, NodesPerBlock, F, OP > &);
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             unsigned char OP> 
      bool operator!=(const private_node_allocator< T, S, NodesPerBlock, F, OP > &, 
                      const private_node_allocator< T, S, NodesPerBlock, F, OP > &);
  }
}

    Описывает функцию, которая создает анонимную общую память, которая может быть разделена между разветвленными процессами

    namespace boost {
  namespace interprocess {
    mapped_region anonymous_shared_memory(std::size_t, void * = 0);
  }
}
    namespace boost {
  namespace interprocess {
    struct create_only_t;
    struct open_only_t;
    struct open_read_only_t;
    struct open_read_private_t;
    struct open_copy_on_write_t;
    struct open_or_create_t;
    static const create_only_t create_only;
    static const open_only_t open_only;
    static const open_read_only_t open_read_only;
    static const open_or_create_t open_or_create;
    static const open_copy_on_write_t open_copy_on_write;
  }
}

    Описывает нумерацию ошибок межпроцессных классов

    namespace boost {
  namespace interprocess {
    enum error_code_t { no_error = = 0, system_error, other_error, 
                        security_error, read_only_error, io_error, path_error, 
                        not_found_error, busy_error, already_exists_error, 
                        not_empty_error, is_directory_error, 
                        out_of_space_error, out_of_memory_error, 
                        out_of_resource_error, lock_error, sem_error, 
                        mode_error, size_error, corrupted_error, 
                        not_such_file_or_directory, invalid_argument, 
                        timeout_when_locking_error, 
                        timeout_when_waiting_error, owner_dead_error };
    typedef int native_error_t;
  }
}

    Описывает исключения, выброшенные межпроцессными классами

    namespace boost {
  namespace interprocess {
    class interprocess_exception;
    class lock_exception;
    class bad_alloc;
  }
}

    Описывает классы file_mapping и mapped region

    namespace boost {
  namespace interprocess {
    class file_mapping;
  }
}

    Описывает индексный адаптер импульса::map-контейнер, чтобы использовать его в качестве имени/общего индекса памяти

    namespace boost {
  namespace interprocess {
    template<typename MapConfig> class flat_map_index;
  }
}

    Описывает индексный адаптер импульса::intrusive::set контейнер, чтобы использовать его в качестве имени/общего индекса памяти

    namespace boost {
  namespace interprocess {
    template<typename MapConfig> class iset_index;
  }
}

    Описывает адаптер индекса импульса::intrusive::unordered_set container, чтобы использовать его в качестве имени/общего индекса памяти

    namespace boost {
  namespace interprocess {
    template<typename MapConfig> class iunordered_set_index;
  }
}

    Описывает индексный адаптер импульса::map-контейнер, чтобы использовать его в качестве имени/общего индекса памяти

    namespace boost {
  namespace interprocess {
    template<typename MapConfig> class map_index;
  }
}

    Описывает адаптер нулевого индекса, так что если мы не хотим строить названные объекты, мы можем использовать этот тип нулевого индекса для экономии ресурсов.

    namespace boost {
  namespace interprocess {
    template<typename MapConfig> class null_index;
  }
}

    Описывает адаптер индекса импульса::unordered_map контейнер, чтобы использовать его как имя / общий индекс памяти

    namespace boost {
  namespace interprocess {
    template<typename MapConfig> class unordered_map_index;
  }
}

    Этот файл заголовка вперед объявляет основные типы межпроцессов:

    Следующие механизмы и замки синхронизации:

    Следующие семейства мутекс:

    Следующие распределители:

    Следующие алгоритмы распределения:

    Следующие типы индексов:

    Следующие управляемые типы памяти:

    Следующие виды исключений:

    Следующие типы потоков:

    Следующие типы умных указателей:

    Следующие типы межпроцессных коммуникаций:

    Описывает очередь сообщений между процессами. Этот класс позволяет отправлять сообщения между процессами и позволяет блокировать, не блокировать и синхронизировать отправку и получение.

    namespace boost {
  namespace interprocess {
    template<typename VoidPointer> class message_queue_t;
    typedef message_queue_t< offset_ptr< void > > message_queue;
  }
}

    Описывает именованный класс пользователя распределения памяти.

    namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_external_buffer;
    typedef basic_managed_external_buffer< char,rbtree_best_fit< null_mutex_family >,iset_index > managed_external_buffer;
    typedef basic_managed_external_buffer< wchar_t,rbtree_best_fit< null_mutex_family >,iset_index > wmanaged_external_buffer;
  }
}

    Описывает именуемый класс пользователя выделения кучи памяти.

    namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_heap_memory;
    typedef basic_managed_heap_memory< char,rbtree_best_fit< null_mutex_family >,iset_index > managed_heap_memory;
    typedef basic_managed_heap_memory< wchar_t,rbtree_best_fit< null_mutex_family >,iset_index > wmanaged_heap_memory;
  }
}
    namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_mapped_file;
    typedef basic_managed_mapped_file< char,rbtree_best_fit< mutex_family >,iset_index > managed_mapped_file;
    typedef basic_managed_mapped_file< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_mapped_file;
  }
}
    namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_shared_memory;
    typedef basic_managed_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_shared_memory;
    typedef basic_managed_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_shared_memory;
    typedef basic_managed_shared_memory< char,rbtree_best_fit< mutex_family, void * >,iset_index > fixed_managed_shared_memory;
    typedef basic_managed_shared_memory< wchar_t,rbtree_best_fit< mutex_family, void * >,iset_index > wfixed_managed_shared_memory;
  }
}
    namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_windows_shared_memory;
    typedef basic_managed_windows_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_windows_shared_memory;
    typedef basic_managed_windows_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_windows_shared_memory;
  }
}
    namespace boost {
  namespace interprocess {
    template<typename CharType, typename AllocationAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class basic_managed_xsi_shared_memory;
    typedef basic_managed_xsi_shared_memory< char,rbtree_best_fit< mutex_family >,iset_index > managed_xsi_shared_memory;
    typedef basic_managed_xsi_shared_memory< wchar_t,rbtree_best_fit< mutex_family >,iset_index > wmanaged_xsi_shared_memory;
  }
}

    Описывает картографический класс региона

    namespace boost {
  namespace interprocess {
    class mapped_region;
  }
}

    Описывает наиболее подходящий алгоритм, основанный на навязчивом красно-черном дереве, используемом для распределения объектов в общей памяти. Этот класс предназначен в качестве базового класса для реализации одного сегмента и нескольких сегментов.

    namespace boost {
  namespace interprocess {
    template<typename MutexFamily, typename VoidPointer, 
             std::size_t MemAlignment> 
      class rbtree_best_fit;
  }
}

    Описывает алгоритм последовательной подгонки, используемый для распределения объектов в общей памяти.

    namespace boost {
  namespace interprocess {
    template<typename MutexFamily, typename VoidPointer> class simple_seq_fit;
  }
}

    Описывает умный указатель, который хранит смещение между этим указателем и целевым указателем, называемым offset_ptr.

    namespace boost {
  namespace interprocess {
    template<typename PointedType, typename DifferenceType, 
             typename OffsetType, std::size_t OffsetAlignment> 
      class offset_ptr;
    template<typename E, typename T, typename W, typename X, typename Y, 
             std::size_t Z> 
      std::basic_ostream< E, T > & 
      operator<<(std::basic_ostream< E, T > &, 
                 offset_ptr< W, X, Y, Z > const &);
    template<typename E, typename T, typename W, typename X, typename Y, 
             std::size_t Z> 
      std::basic_istream< E, T > & 
      operator>>(std::basic_istream< E, T > &, offset_ptr< W, X, Y, Z > &);
    // Simulation of static_cast between pointers. Never throws. 
    template<typename T1, typename P1, typename O1, std::size_t A1, 
             typename T2, typename P2, typename O2, std::size_t A2> 
      boost::interprocess::offset_ptr< T1, P1, O1, A1 > 
      static_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r);
    // Simulation of const_cast between pointers. Never throws. 
    template<typename T1, typename P1, typename O1, std::size_t A1, 
             typename T2, typename P2, typename O2, std::size_t A2> 
      boost::interprocess::offset_ptr< T1, P1, O1, A1 > 
      const_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r);
    // Simulation of dynamic_cast between pointers. Never throws. 
    template<typename T1, typename P1, typename O1, std::size_t A1, 
             typename T2, typename P2, typename O2, std::size_t A2> 
      boost::interprocess::offset_ptr< T1, P1, O1, A1 > 
      dynamic_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r);
    // Simulation of reinterpret_cast between pointers. Never throws. 
    template<typename T1, typename P1, typename O1, std::size_t A1, 
             typename T2, typename P2, typename O2, std::size_t A2> 
      boost::interprocess::offset_ptr< T1, P1, O1, A1 > 
      reinterpret_pointer_cast(const boost::interprocess::offset_ptr< T2, P2, O2, A2 > & r);
  }
}

    Описывает класс разрешений

    namespace boost {
  namespace interprocess {
    class permissions;
  }
}

    Описывает объект, помещенный в сегмент памяти, который предоставляет возможности выделения именованных объектов для выделений одного и нескольких сегментов.

    namespace boost {
  namespace interprocess {
    template<typename MemoryAlgorithm> class segment_manager_base;
    template<typename CharType, typename MemoryAlgorithm, 
             template< class IndexConfig > class IndexType> 
      class segment_manager;
  }
}

    Описывает класс управления объектами общей памяти.

    namespace boost {
  namespace interprocess {
    class shared_memory_object;
  }
}

    Описывает функтор для удаления объектов из сегмента.

    namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager> class deleter;
  }
}

    Описывает утилиту для формирования общего указателя из этого

    Описывает навязчивый указатель собственности.

    namespace boost {
  namespace interprocess {
    template<typename T, typename VoidPointer> class intrusive_ptr;
    template<typename T, typename U, typename VP> 
      bool operator==(intrusive_ptr< T, VP > const &, 
                      intrusive_ptr< U, VP > const &);
    template<typename T, typename U, typename VP> 
      bool operator!=(intrusive_ptr< T, VP > const &, 
                      intrusive_ptr< U, VP > const &);
    template<typename T, typename VP> 
      bool operator==(intrusive_ptr< T, VP > const &, 
                      const typename intrusive_ptr< T, VP >::pointer &);
    template<typename T, typename VP> 
      bool operator!=(intrusive_ptr< T, VP > const &, 
                      const typename intrusive_ptr< T, VP >::pointer &);
    template<typename T, typename VP> 
      bool operator==(const typename intrusive_ptr< T, VP >::pointer &, 
                      intrusive_ptr< T, VP > const &);
    template<typename T, typename VP> 
      bool operator!=(const typename intrusive_ptr< T, VP >::pointer &, 
                      intrusive_ptr< T, VP > const &);
    template<typename T, typename VP> 
      bool operator<(intrusive_ptr< T, VP > const &, 
                     intrusive_ptr< T, VP > const &);
    template<typename T, typename VP> 
      void swap(intrusive_ptr< T, VP > &, intrusive_ptr< T, VP > &);
    template<typename E, typename T, typename Y, typename VP> 
      std::basic_ostream< E, T > & 
      operator<<(std::basic_ostream< E, T > & os, 
                 intrusive_ptr< Y, VP > const & p);
    template<typename T, typename VP> 
      boost::interprocess::intrusive_ptr< T, VP >::pointer 
      to_raw_pointer(intrusive_ptr< T, VP >);
  }
}

    Описывает умный указатель scoped_ptr

    namespace boost {
  namespace interprocess {
    template<typename T, typename Deleter> class scoped_ptr;
    template<typename T, typename D> 
      void swap(scoped_ptr< T, D > &, scoped_ptr< T, D > &);
    template<typename T, typename D> 
      scoped_ptr< T, D >::pointer to_raw_pointer(scoped_ptr< T, D > const &);
  }
}

    Описывает умный указатель shared_ptr

    namespace boost {
  namespace interprocess {
    template<typename T, typename VoidAllocator, typename Deleter> 
      class enable_shared_from_this;
    template<typename T, typename VoidAllocator, typename Deleter> 
      class shared_ptr;
    template<typename T, typename ManagedMemory> struct managed_shared_ptr;
    template<typename T, typename VoidAllocator, typename Deleter, typename U, 
             typename VoidAllocator2, typename Deleter2> 
      bool operator==(shared_ptr< T, VoidAllocator, Deleter > const & a, 
                      shared_ptr< U, VoidAllocator2, Deleter2 > const & b);
    template<typename T, typename VoidAllocator, typename Deleter, typename U, 
             typename VoidAllocator2, typename Deleter2> 
      bool operator!=(shared_ptr< T, VoidAllocator, Deleter > const & a, 
                      shared_ptr< U, VoidAllocator2, Deleter2 > const & b);
    template<typename T, typename VoidAllocator, typename Deleter, typename U, 
             typename VoidAllocator2, typename Deleter2> 
      bool operator<(shared_ptr< T, VoidAllocator, Deleter > const & a, 
                     shared_ptr< U, VoidAllocator2, Deleter2 > const & b);
    template<typename T, typename VoidAllocator, typename Deleter> 
      void swap(shared_ptr< T, VoidAllocator, Deleter > & a, 
                shared_ptr< T, VoidAllocator, Deleter > & b);
    template<typename T, typename VoidAllocator, typename Deleter, typename U> 
      shared_ptr< T, VoidAllocator, Deleter > 
      static_pointer_cast(shared_ptr< U, VoidAllocator, Deleter > const & r);
    template<typename T, typename VoidAllocator, typename Deleter, typename U> 
      shared_ptr< T, VoidAllocator, Deleter > 
      const_pointer_cast(shared_ptr< U, VoidAllocator, Deleter > const & r);
    template<typename T, typename VoidAllocator, typename Deleter, typename U> 
      shared_ptr< T, VoidAllocator, Deleter > 
      dynamic_pointer_cast(shared_ptr< U, VoidAllocator, Deleter > const & r);
    template<typename T, typename VoidAllocator, typename Deleter> 
      T * to_raw_pointer(shared_ptr< T, VoidAllocator, Deleter > const & p);
    template<typename E, typename T, typename Y, typename VoidAllocator, 
             typename Deleter> 
      std::basic_ostream< E, T > & 
      operator<<(std::basic_ostream< E, T > & os, 
                 shared_ptr< Y, VoidAllocator, Deleter > const & p);
    template<typename T, typename ManagedMemory> 
      managed_shared_ptr< T, ManagedMemory >::type 
      make_managed_shared_ptr(T *, ManagedMemory &);
    template<typename T, typename ManagedMemory> 
      managed_shared_ptr< T, ManagedMemory >::type 
      make_managed_shared_ptr(T *, ManagedMemory &, const std::nothrow_t &);
  }
}

    Этот заголовок предоставляет утилиты для определения уникального_ptr, который хорошо играет с управляемыми сегментами.

    namespace boost {
  namespace interprocess {
    template<typename T, typename ManagedMemory> struct managed_unique_ptr;
    template<typename T, typename ManagedMemory> 
      managed_unique_ptr< T, ManagedMemory >::type 
      make_managed_unique_ptr(T *, ManagedMemory &);
  }
}

    Описывает умный указатель weak_ptr.

    namespace boost {
  namespace interprocess {
    template<typename T, typename A, typename D> class weak_ptr;
    template<typename T, typename ManagedMemory> struct managed_weak_ptr;
    template<typename T, typename A, typename D, typename U, typename A2, 
             typename D2> 
      bool operator<(weak_ptr< T, A, D > const & a, 
                     weak_ptr< U, A2, D2 > const & b);
    template<typename T, typename A, typename D> 
      void swap(weak_ptr< T, A, D > & a, weak_ptr< T, A, D > & b);
    template<typename T, typename ManagedMemory> 
      managed_weak_ptr< T, ManagedMemory >::type 
      make_managed_weak_ptr(T *, ManagedMemory &);
  }
}

    Этот файл определяет классы basic_bufferbuf, basic_ibufferstream, basic_obufferstream и basic_bufferstream. Эти классы представляют собой потоки и потоки, источники или назначения которых являются буферами символов фиксированного размера.

    namespace boost {
  namespace interprocess {
    template<typename CharT, typename CharTraits> class basic_bufferbuf;
    template<typename CharT, typename CharTraits> class basic_ibufferstream;
    template<typename CharT, typename CharTraits> class basic_obufferstream;
    template<typename CharT, typename CharTraits> class basic_bufferstream;
    typedef basic_bufferbuf< char > bufferbuf;
    typedef basic_bufferstream< char > bufferstream;
    typedef basic_ibufferstream< char > ibufferstream;
    typedef basic_obufferstream< char > obufferstream;
    typedef basic_bufferbuf< wchar_t > wbufferbuf;
    typedef basic_bufferstream< wchar_t > wbufferstream;
    typedef basic_ibufferstream< wchar_t > wibufferstream;
    typedef basic_obufferstream< wchar_t > wobufferstream;
  }
}

    Этот файл определяет классы basic_vectorbuf, basic_ivectorstream, basic_ovectorstream и basic_vectorstream. Эти классы представляют собой потоки и потоки, источниками или назначениями которых являются векторы, подобные STL, которые могут быть заменены внешними векторами, чтобы избежать ненужных выделений / копий.

    namespace boost {
  namespace interprocess {
    template<typename CharVector, typename CharTraits> class basic_vectorbuf;
    template<typename CharVector, typename CharTraits> 
      class basic_ivectorstream;
    template<typename CharVector, typename CharTraits> 
      class basic_ovectorstream;
    template<typename CharVector, typename CharTraits> class basic_vectorstream;
  }
}

    Описывает класс, который обертывает возможности блокировки файлов.

    namespace boost {
  namespace interprocess {
    class file_lock;
  }
}

    Описывает переменные interprocess_condition class

    namespace boost {
  namespace interprocess {
    class interprocess_condition;
  }
}

    Описывает переменные interprocess_condition_any

    namespace boost {
  namespace interprocess {
    class interprocess_condition_any;
  }
}

    Описывает класс mutex, который может быть помещен в память, разделяемую несколькими процессами.

    namespace boost {
  namespace interprocess {
    class interprocess_mutex;
  }
}

    Классы interprocess_recursive_mutex и shared_recursive_try_mutex

    namespace boost {
  namespace interprocess {
    class interprocess_recursive_mutex;
  }
}

    Описывает класс interprocess_semaphore для межпроцессной синхронизации

    namespace boost {
  namespace interprocess {
    class interprocess_semaphore;
  }
}

    Обсуждение Interprocess_sharable_mutex класс

    namespace boost {
  namespace interprocess {
    class interprocess_sharable_mutex;
  }
}

    Обсуждение Interprocess_upgradable_mutex класс

    namespace boost {
  namespace interprocess {
    class interprocess_upgradable_mutex;
  }
}

    Опции блокировки, связанные с конструкторами блокировки interprocess_mutex.

    namespace boost {
  namespace interprocess {
    struct defer_lock_type;
    struct try_to_lock_type;
    struct accept_ownership_type;
    static const defer_lock_type defer_lock;
    static const try_to_lock_type try_to_lock;
    static const accept_ownership_type accept_ownership;
  }
}

    Описывает общий алгоритм соответствия семейства interprocess_mutex, используемый для распределения объектов в общей памяти.

    namespace boost {
  namespace interprocess {
    struct mutex_family;
    struct null_mutex_family;
  }
}

    Описывает названный класс условий для синхронизации между процессами

    namespace boost {
  namespace interprocess {
    class named_condition;
  }
}

    Описывает названный класс условий для синхронизации между процессами

    namespace boost {
  namespace interprocess {
    class named_condition_any;
  }
}

    Назван класс mutex для синхронизации между процессами

    namespace boost {
  namespace interprocess {
    class named_mutex;
  }
}

    Оригинальное название: Named_recursive_mutex Класс межпроцессной синхронизации

    namespace boost {
  namespace interprocess {
    class named_recursive_mutex;
  }
}

    Описывает именуемый класс семафоров для межпроцессной синхронизации

    namespace boost {
  namespace interprocess {
    class named_semaphore;
  }
}

    Описано название класса mutex для межпроцессной синхронизации

    namespace boost {
  namespace interprocess {
    class named_sharable_mutex;
  }
}

    Описано название модернизируемого класса mutex для межпроцессной синхронизации

    namespace boost {
  namespace interprocess {
    class named_upgradable_mutex;
  }
}

    Обсуждение Null_mutex классы

    namespace boost {
  namespace interprocess {
    class null_mutex;
  }
}

    Описывает класс scoped_lock.

    namespace boost {
  namespace interprocess {
    template<typename Mutex> class scoped_lock;
  }
}

    Описывает класс upgradable_lock, который служит для приобретения модифицируемого замка mutex.

    namespace boost {
  namespace interprocess {
    template<typename SharableMutex> class sharable_lock;
  }
}

    Описывает класс upgradable_lock, который служит для приобретения модифицируемого замка mutex.

    namespace boost {
  namespace interprocess {
    template<typename UpgradableMutex> class upgradable_lock;
  }
}

    Описывает класс, представляющий собой общую память нативных окон.

    namespace boost {
  namespace interprocess {
    class windows_shared_memory;
  }
}

    Описывает класс, представляющий тип ключа xsi.

    namespace boost {
  namespace interprocess {
    class xsi_key;
  }
}

    Описывает класс, представляющий собой общую память xsi.

    namespace boost {
  namespace interprocess {
    class xsi_shared_memory;
  }
}
    Copyright © 2005-2015 Ion Gaztanaga

    Распространяется под лицензией Boost Software License, версия 1.0. (См. сопроводительный файл LICENSE_1_0.txt или копию по адресу) http://www.boost.org/LICENSE_1_0.txt

    PrevUpHomeNext

    Статья Indexes and Reference раздела The Boost C++ Libraries BoostBook Documentation Subset Chapter 16. Boost.Interprocess может быть полезна для разработчиков на c++ и boost.




    Материалы статей собраны из открытых источников, владелец сайта не претендует на авторство. Там где авторство установить не удалось, материал подаётся без имени автора. В случае если Вы считаете, что Ваши права нарушены, пожалуйста, свяжитесь с владельцем сайта.


    :: Главная :: Chapter 16. Boost.Interprocess ::

    реклама
    ©KANSoftWare (разработка программного обеспечения, создание программ, создание интерактивных сайтов), 2007
    Top.Mail.Ru

    Время компиляции файла: 2024-08-30 11:47:00
    2025-07-05 03:32:03/0.039320945739746/1