Class reversible_ptr_container

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

Иерархия:

• Обратимый_ptr_контейнер
  • ptr_sequence_adapter
    • ptr_vector
    • ptr_list
    • ptr_deque
    • ptr_array
  • associative_ptr_container
    • ptr_set_adapter
    • ptr_multiset_adapter
    • ptr_map_adapter
    • ptr_multi_map_adapter
      • ptr_set
      • ptr_multi_set
      • ptr_map
      • ptr_multimap

Навигат:

• Домой
• ссылка

синопсис:

namespace boost
{      
    template
    < 
        class T, 
        class CloneAllocator,
        class VoidPtrContainer
    >
    class reversible_ptr_container 
    {
    public: // typedefs
        typedef  T*                                           value_type;
        typedef  T&                                           reference;
        typedef  const T&                                     const_reference;
        typedef  implementation defined                       iterator;
        typedef  implementation defined                       const_iterator;
        typedef  typename VoidPtrContainer::differnce_type    difference_type; 
        typedef  typename VoidPtrContainer::size_type         size_type;
        typedef  typename VoidPtrContainer::allocator_type    allocator_type;
        typedef  implementation defined                       reverse_iterator;
        typedef  implementation defined                       const_reverse_iterator;
        typedef  implementation defined                       auto_type;
    
    public: // construct/copy/destroy
        reversible_ptr_container();
        explicit reversible_ptr_container( const reversible_ptr_container& r );                
        template< class Derived >
        explicit reversible_ptr_container( const reversible_ptr_container<Derived>& r );
        explicit reversible_ptr_container( std::auto_ptr<reversible_ptr_container> r );
        template< class InputIterator >
        reversible_ptr_container( InputIterator first, InputIterator last );
        
        ~reversible_ptr_container();
        reversible_ptr_container&  operator=( const reversible_ptr_container& r );
        template<class Derived>
        reversible_ptr_container&  operator=( const reversible_ptr_container<Derived>& r );
        reversible_ptr_container&  operator=( std::auto_ptr<reversible_ptr_container> r );
        allocator_type             get_allocator() const;                                      
    
    public: // iterators
        iterator                begin();
        const_iterator          begin() const;
        iterator                end();
        const_iterator          end() const;
        reverse_iterator        rbegin();
        const_reverse_iterator  rbegin() const;
        reverse_iterator        rend();
        const_reverse_iterator  rend() const;
        
    public: // capacity
        size_type  size() const;
        size_type  max_size() const;
        bool       empty() const;       
    
    public: // modifiers
        void                     swap( reversible_ptr_container& r );
        void                     clear():
        VoidPtrContainer&        base();
        const VoidPtrContainer&  base() const;
    
    public: // pointer container requirements
        auto_type                                replace( iterator position, T* x );
        template< class U >
        auto_type                                replace( iterator position, std::auto_ptr<U> x );    
        std::auto_ptr<reversible_ptr_container>  clone() const;    
        std::auto_ptr<reversible_ptr_container>  release();
        auto_type                                release( iterator position );
                    
    }; //  class 'reversible_ptr_container'
    // comparison            
    template < class T, class CA, class VPC >
    bool operator==( const reversible_ptr_container<T,CA,VPC>& x,
                     const reversible_ptr_container<T,CA,VPC>& y);
    
    template < class T, class CA, class VPC  >
    bool operator<( const reversible_ptr_container<T,CA,VPC>& x,
                    const reversible_ptr_container<T,CA,VPC>& y);
    
    template < class T, class CA, class VPC  >
    bool operator!=( const reversible_ptr_container<T,CA,VPC>& x,
                     const reversible_ptr_container<T,CA,VPC>& y);
    
    template < class T,  class CA, class VPC >
    bool operator>( const reversible_ptr_container<T,CA,VPC>& x,
                    const reversible_ptr_container<T,CA,VPC>& y);
    
    template < class T,  class CA, class VPC >
    bool operator>=( const reversible_ptr_container<T,CA,VPC>& x,
                     const reversible_ptr_container<T,CA,VPC>& y);
    
    template < class T,  class CA, class VPC >
    bool operator<=( const reversible_ptr_container<T,CA,VPC>& x,
                     const reversible_ptr_container<T,CA,VPC>& y);
    template< class T,  class CA, class VPC  >
    void swap( reversible_ptr_container<T,CA,VPC>& x,
               reversible_ptr_container<T,CA,VPC>& y );
    // cloneability
    template< class T,  class CA, class VPC >
    reversible_ptr_container<T,CA,VPC>*
    new_clone( const reversible_ptr_container<T,CA,VPC>& r );
    // null predicate
    template< class Iterator >
    bool is_null( Iterator i );
    
    // serialization
    template<class Archive, class T, class CA, class VPC>
    void serialize( Archive& ar, reversible_ptr_container<T,CÁ,VPC>& c, const unsigned int version );
} // namespace 'boost'

Semantics

iterator i = ...;
i.base();

T* operator->() const;
T& operator*() const;
T* release();
~auto_type();
operator implementation-defined bool();

auto_type ptr   = ...;
auto_type other = boost::ptr_container::move( ptr );
return boost::ptr_container::move( other );

operation( const ptr_container& l, const ptr_container& r );