++++++++++++++++++++++++++++++++++
 |Boost| Pointer Container Library
++++++++++++++++++++++++++++++++++
 
.. |Boost| image:: boost.png

Class ``ptr_vector``
--------------------

A ``ptr_vector<T>`` is a pointer container that uses an underlying ``std::vector<void*>``
to store the pointers. 

**Hierarchy:**

- `reversible_ptr_container <reversible_ptr_container.html>`_

  - `ptr_sequence_adapter <ptr_sequence_adapter.html>`_

    - ``ptr_vector``
    - `ptr_list <ptr_list.html>`_
    - `ptr_deque <ptr_deque.html>`_
    - `ptr_array <ptr_array.html>`_

**Navigate:**

- `home <ptr_container.html>`_
- `reference <reference.html>`_

**Synopsis:**

.. parsed-literal::  
           
        namespace boost
        {      
        
            template
            < 
                class T, 
                class CloneAllocator = heap_clone_allocator,
                class Allocator      = std::allocator<void*>
            >
            class ptr_vector : public ptr_sequence_adapter
                                      <
                                          T,
                                          std::vector<void*,Allocator>,
                                          CloneAllocator
                                      >
            {
            public: // `construction`_
                explicit ptr_vector( size_type to_reserve );
            
            public: // capacity_
                size_type  capacity() const;
                void       reserve( size_type n );
            
            public: // `element access`_
                T&        operator[]( size_type n );
                const T&  operator[]( size_type n ) const;
                T&        at( size_type n );
                const T&  at( size_type n ) const;

            public: // `pointer container requirements`_
               auto_type replace( size_type idx, T* x );  
               template< class U >
               auto_type replace( size_type idx, std::auto_ptr<U> x );  
               bool      is_null( size_type idx ) const;
               
            public: // `C-array support`_
               void transfer( iterator before, T** from, size_type size, bool delete_from = true );
               T**  c_array();

            };
           
        } // namespace 'boost'  


Semantics
---------

.. _`construction`:

Semantics: construction
^^^^^^^^^^^^^^^^^^^^^^^

- ``explicit ptr_vector( size_type to_reserve );``

    - constructs an empty vector with a buffer
      of size least ``to_reserve``

.. _`capacity`:

Semantics: capacity
^^^^^^^^^^^^^^^^^^^

- ``size_type capacity() const;``

    - Effects: Returns the size of the allocated buffer

    - Throws: Nothing

- ``void reserve( size_type n );``

    - Requirements: ``n <= max_size()``
                 
    - Effects: Expands the allocated buffer

    - Postcondition: ``capacity() >= n``

    - Throws: ``std::length_error()`` if ``n > max_size()``


.. _`element access`:

Semantics: element access
^^^^^^^^^^^^^^^^^^^^^^^^^

- ``T& operator[]( size_type n );``
- ``const T& operator[]( size_type n ) const;``

    - Requirements: ``n < size()``

    - Effects: Returns a reference to the ``n``'th element

    - Throws: Nothing

- ``T& at( size_type n );``
- ``const T& at( size_type n ) const;``

    - Requirements: ``n < size()``

    - Effects: Returns a reference to the ``n``'th element

    - Throws: ``bad_index`` if ``n >= size()``


.. _`pointer container requirements`:

Semantics: pointer container requirements
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

- ``auto_type replace( size_type idx, T* x );``    

    - Requirements: `` x != 0 and idx < size()``

    - Effects: returns the object indexed by ``idx`` and replaces it with ``x``.

    - Throws: ``bad_index`` if ``idx >= size()`` and ``bad_pointer`` if ``x == 0``.

    - Exception safety: Strong guarantee

- ``template< class U > auto_type replace( size_type idx, std::auto_ptr<U> x );``

    - Effects: ``return replace( idx, x.release() );``  

- ``bool is_null( size_type idx ) const;``

    - Requirements: ``idx < size()``

    - Effects: returns whether the pointer at index ``idx`` is null

    - Exception safety: Nothrow guarantee


.. _`C-array support`:

Semantics: C-array support
^^^^^^^^^^^^^^^^^^^^^^^^^^

- ``void transfer( iterator before, T** from, size_type size, bool delete_from = true );``

    - Requirements:  ``from != 0``
    
    - Effects: Takes ownership of the dynamic array ``from``
    
    - Exception safety: Strong guarantee if ``delete_from == true``; if ``delete_from == false``,
      and an exception is thrown, the container fails to take ownership.                  
    
    - Remarks: Eventually calls ``delete[] from`` if ``delete_from == true``.   
         
- ``T** c_array();``

    - Returns: ``0`` if the container is empty; otherwise a pointer to the first element of the stored array

    - Throws: Nothing
    
.. raw:: html 

        <hr>

:Copyright:     Thorsten Ottosen 2004-2007. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see LICENSE_1_0.txt__).

__ http://www.boost.org/LICENSE_1_0.txt