my_container.push_back( 0 );            // throws bad_ptr 
    my_container.replace( an_iterator, 0 ); // throws bad_ptr
    my_container.insert( an_iterator, 0 );  // throws bad_ptr       
    std::auto_ptr<T> p( 0 );
    my_container.push_back( p );            // throws bad_ptr                                                          

    ptr_vector<X> pvec; 
    std::vector<X*> vec;
    *vec.begin()  = new X;   // fine, memory leak
    *pvec.begin() = new X;   // compile time error
    ( *vec.begin() )->foo(); // call X::foo(), a bit clumsy
    pvec.begin()->foo();     // no indirection needed
    *vec.front()  = X();     // overwrite first element
    pvec.front()  = X();     // no indirection needed

    ptr_vector<T> vec1; 
    ...
    ptr_vector<T> vec2( vec1.clone() ); // deep copy objects of 'vec1' and use them to construct 'vec2', could be very expensive
    vec2 = vec1.release();              // give up ownership of pointers in 'vec1' and pass the ownership to 'vec2', rather cheap
    vec2.release();                     // give up ownership; the objects will be deallocated if not assigned to another container
    vec1 = vec2;                        // deep copy objects of 'vec2' and assign them to 'vec1', could be very expensive 
    ptr_vector<T> vec3( vec1 );         // deep copy objects of 'vec1', could be very expensive

     // a class that has no normal copy semantics
    class X : boost::noncopyable { public: X* clone() const; ... };
                                                                       
    // this will be found by the library by argument dependent lookup (ADL)                                                                  
    X* new_clone( const X& x ) 
    { return x.clone(); }
                                                                       
    // we can now use the interface that requires cloneability
    ptr_vector<X> vec1, vec2;
    ...
    vec2 = vec1.clone();                                 // 'clone()' requires cloning <g> 
    vec2.insert( vec2.end(), vec1.begin(), vec1.end() ); // inserting always means inserting clones 

    class X { ... };                     // assume 'X' is Cloneable 
    X x;                                 // and 'X' can be stack-allocated 
    ptr_list<X> list; 
    list.push_back( new_clone( x ) );    // insert a clone
    list.push_back( new X );             // always give the pointer directly to the container to avoid leaks
    list.push_back( &x );                // don't do this!!! 
    std::auto_ptr<X> p( new X );
    list.push_back( p );                 // give up ownership
    BOOST_ASSERT( p.get() == 0 );

    ptr_deque<T>                    deq; 
    typedef ptr_deque<T>::auto_type auto_type;
    
    // ... fill the container somehow
    
    auto_type ptr  = deq.pop_back();                 // remove back element from container and give up ownership
    auto_type ptr2 = deq.release( deq.begin() + 2 ); // use an iterator to determine the element to release
    ptr            = deq.pop_front();                // supported for 'ptr_list' and 'ptr_deque'
                                    
    deq.push_back( ptr.release() );                  // give ownership back to the container
    

    ptr_list<X> list; ptr_vector<X> vec;
    ...
    //
    // note: no cloning happens in these examples                                
    //
    list.transfer( list.begin(), vec.begin(), vec );           // make the first element of 'vec' the first element of 'list'
    vec.transfer( vec.end(), list.begin(), list.end(), list ); // put all the lists element into the vector                                 
                  

            This example shows how we can change 
            the Clone Allocator to use the pointer containers
            as view into other containers:

            .. raw:: html
                    :file: tut2.html

    <hr>

    <hr>