mstl_ptr_container.hpp

一个类STL的多平台可移植的算法容器库,主要用于嵌入式系统编程时的内存管理等方面

/*
The young Library
Copyright (c) 2005 by 杨桓

Permission to use, copy, modify, distribute and sell this software for any
purpose is hereby granted without fee, provided that the above copyright
notice appear in all copies and that both that copyright notice and this
permission notice appear in supporting documentation.
The author make no representations about the suitability of this software
for any purpose. It is provided "as is" without express or implied warranty.
*/

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#ifndef __MACRO_CPLUSPLUS_MINI_STL_POINTER_CONTAINER_HEADER_FILE__
#define __MACRO_CPLUSPLUS_MINI_STL_POINTER_CONTAINER_HEADER_FILE__
//-----------------------------------------------------------------------------
#include "mstl_vector.hpp"
#include "mstl_functional.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_MINI_STL_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

//指针容器的迭代器数值类型是T**
//指针容器的数值类型是T*

template< typename T, typename Container = vector<T*> >
class ptr_container
{
protected:
    Container con;

public:
    typedef  T  data_type;
    typedef  ptr_container<T, Container>  self;

    typedef  typename Container::allocator_type          allocator_type;
    typedef  typename Container::value_type              value_type;
    typedef  typename Container::reference               reference;
    typedef  typename Container::const_reference         const_reference;
    typedef  typename Container::pointer                 pointer;
    typedef  typename Container::const_pointer           cons_pointer;
    typedef  typename Container::iterator                iterator;
    typedef  typename Container::const_iterator          const_iterator;
    typedef  typename Container::reverse_iterator        reverse_iterator;
    typedef  typename Container::const_reverse_iterator  const_reverse_iterator;
    typedef  typename Container::size_type               size_type;
    typedef  typename Container::difference_type         difference_type;


    class value_compare : public binary_function<value_type, value_type, bool>
    {
    public:
        bool operator()( const value_type& lhs, const value_type& rhs ) const
        {
            return ( *lhs < *rhs );
        }
    };

    value_compare value_comp() const  {  return value_compare();  }


    ptr_container() : con()  {}

    explicit ptr_container( size_type size ) : con(size)  {}

    template< typename InputIterator >
    ptr_container( InputIterator first, InputIterator last ) : con()
    {
        range_init( first, last );
    }

    ptr_container( const self& rhs )
    {
        con.reserve( rhs.size() );
        range_init( rhs.begin(), rhs.end() );
    }

    self& operator=( const self& rhs )
    {
        if( this != &rhs )
            assign( rhs.begin(), rhs.end() );
        return *this;
    }

    ~ptr_container()
    {
        iterator first = begin();
        iterator last = end();
        for( ; first != last; ++first )
            delete *first;
    }

    iterator begin()              {  return con.begin();  }
    iterator end()                {  return con.end();  }
    const_iterator begin() const  {  return con.begin();  }
    const_iterator end() const    {  return con.end();  }

    reverse_iterator rbegin()              {  return end();  }
    reverse_iterator rend()                {  return begin();  }
    const_reverse_iterator rbegin() const  {  return end();  }
    const_reverse_iterator rend() const    {  return begin();  }

    reference front()              {  return *begin();  }
    reference back()               {  return *(--end());  }
    const_reference front() const  {  return *begin();  }
    const_reference back() const   {  return *(--end());  }

    bool empty() const          {  return con.empty();  }
    size_type size() const      {  return con.size();  }
    size_type space() const     {  return con.space();  }
    size_type capacity() const  {  return con.capacity();  }
    size_type max_size() const  {  return con.max_size();  }

    void reverse()          {  con.reverse();  }
    void swap( self& rhs )  {  con.swap( rhs );  }
    void reserve( size_type new_size )  {  con.reserve( new_size );  }
    void resize( size_type new_size, const_reference value = value_type() );

    reference operator[]( size_type index )
        {  return con[index];  }
    const_reference operator[]( size_type index ) const
        {  return con[index];  }

    reference at( size_type index )
        {  return con.at( index );  }
    const_reference at( size_type index ) const
        {  return con.at( index );  }

    void push_back( const data_type& value )
        {  con.push_back( new data_type(value) );  }
    void push_back( const_reference value )
        {  con.push_back( value );  }

    void push_front( const data_type& value )
        {  con.push_front( new data_type(value) );  }
    void push_front( const_reference value )
        {  con.push_front( value );  }

    void pop_back()
        {  delete *( --end() );  con.pop_back();  }
    void pop_front()
        {  delete *( begin() );  con.pop_front();  }

    void clear()
    {
        iterator first = begin();
        iterator last = end();
        for( ; first != last; ++first )
            delete *first;
        con.clear();
    }

    iterator erase( iterator position )
    {
        if( position != end() )
            delete *position;
        con.erase( position );
    }
    iterator erase( iterator first, iterator last )
    {
        iterator temp = first;
        for( ; temp != last; ++temp )
            delete *temp;
        con.erase( first, last );
    }


    void assign( size_type new_size )
    {
        iterator first = begin();
        iterator last = end();
        for( ; first != last; ++first )
            delete *first;
        con.assign( new_size, NULL_POINTER );
    }

    template< typename InputIterator >
    void assign( InputIterator first, InputIterator last );


    iterator insert( iterator position, const_reference value = value_type() )
        {  con.insert( position, value );  }

    template< typename InputIterator >
    void insert( iterator position, InputIterator first, InputIterator last );

protected:
    template< typename InputIterator >
    void range_init( InputIterator first, InputIterator last )
    {
        for( ; first != last; ++first )
            con.push_back( new data_type(*first) );
    }

};  //end ptr_container

//-----------------------------------------------------------------------------

template< typename T, typename Container >
void ptr_container<T, Container>::resize( size_type new_size,
                                          const_reference value )
{
    if( new_size < size() )
    {
        iterator first = begin() + new_size;
        iterator last = end();
        for( ; first != last; ++first )
            delete *first;
    }
    con.resize( new_size, value );
}
//-----------------------------------------------------------------------------

template< typename T, typename Container >
template< typename InputIterator >
void ptr_container<T, Container>::assign( InputIterator first,
                                          InputIterator last )
{
    iterator iter1 = begin();
    iterator iter2 = end();
    for( ; iter1 != iter2 && first != last; ++iter1,++first )
        **iter1 = *first;
    if( iter1 != iter2 )
        erase( iter1, iter2 );
    else
    {
        for( ; first != last; ++first )
            con.push_back( new data_type(*first) );
    }
}
//-----------------------------------------------------------------------------

template< typename T, typename Container >
template< typename InputIterator >
void ptr_container<T, Container>::insert( iterator position,
                                          InputIterator first,
                                          InputIterator last )
{
    typedef  typename iterator_traits<InputIterator>::difference_type  diff_t;

    diff_t len = distance( first, last );
    diff_t pos = position - begin();  //迭代器可能失效，需记住偏移位置
    con.insert( position, len, value_type() );
    position = begin() + pos;
    for( ; len > 0; ++first,++position,--len )
        *position = new data_type( *first );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

template< typename T, typename Container >
inline bool operator==( const ptr_container<T, Container>& lhs,
                        const ptr_container<T, Container>& rhs )
{
    return ( lhs.size() == rhs.size()
             && equal( lhs.begin(), lhs.end(),
                       rhs.begin(), lhs.value_comp() ) );
}

template< typename T, typename Container >
inline bool operator!=( const ptr_container<T, Container>& lhs,
                        const ptr_container<T, Container>& rhs )
{
    return !( lhs == rhs );
}

template< typename T, typename Container >
inline bool operator<( const ptr_container<T, Container>& lhs,
                       const ptr_container<T, Container>& rhs )
{
    if( lhs.begin() == rhs.begin() || lhs.size() > rhs.size() )
        return false;
    return lexicographical_compare( lhs.begin(), lhs.end(),
                                    rhs.begin(), rhs.end(), lhs.value_comp() );
}

template< typename T, typename Container >
inline bool operator>( const ptr_container<T, Container>& lhs,
                       const ptr_container<T, Container>& rhs )
{
    return ( rhs < lhs );
}

template< typename T, typename Container >
inline bool operator<=( const ptr_container<T, Container>& lhs,
                        const ptr_container<T, Container>& rhs )
{
    return !( rhs < lhs );
}

template< typename T, typename Container >
inline bool operator>=( const ptr_container<T, Container>& lhs,
                        const ptr_container<T, Container>& rhs )
{
    return !( lhs < rhs );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_MINI_STL_END_NAMESPACE__
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------