Pointer Container Library

Indirected functions

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

Когда контейнер использует void* внутри, мы можем использовать класс void_ptr_indirect_fun; в противном случае мы используем класс indirect_fun.

Пример:

std::string* bar = new std::string("bar");
std::string* foo = new std::string("foo");
BOOST_ASSERT( indirect_fun< std::less<std::string> >()( bar, foo ) == true );
BOOST_ASSERT( make_indirect_fun( std::less<std::string>() )( foo, bar ) == false );   
void*       vptr1  = ptr1;
void*       vptr2  = ptr2;
void_ptr_indirect_fun< std::less<std::string>, std::string> cast_fun;
BOOST_CHECK( cast_fun( vptr1, vptr2 ) == true );

См. также:

• результат_о
• показатель
• ptr_set
• ptr_multiset

Navigate

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

Замечания:

Класс indirect_fun будет работать с умными указателями, такими как boost::shared_ptr из-за особенностей типа pointee::type от заголовка .

Синопсис:

Поскольку определение предикатов несколько тривиально, только первая операция расширяется в линию.

namespace boost
{      
    template< class Fun >
    struct indirect_fun
    {
        indirect_fun() : fun(Fun())
        { }
        
        indirect_fun( Fun f ) : fun(f)
        { }
    
        template< class T >
        typename result_of< Fun( typename pointee<T>::type ) >::type 
        operator()( const T& r ) const
        { 
            return fun( *r );
        }
    
        template< class T, class U >
        typename result_of< Fun( typename pointee<T>::type, 
                                 typename pointee<U>::type ) >::type 
        operator()( const T& r, const U& r2 ) const
        { 
            return fun( *r, *r2 );
        }
    
    private:
        Fun fun;
    };
    template< class Fun >
    inline indirect_fun<Fun> make_indirect_fun( Fun f )
    {
        return indirect_fun<Fun>( f );
    }        
    template< class Fun, class Arg1, class Arg2 = Arg1 >
    struct void_ptr_indirect_fun
    {
        void_ptr_indirect_fun() : fun(Fun())
        { }
        void_ptr_indirect_fun( Fun f ) : fun(f)
        { }
        typename result_of< Fun( Arg1 ) >::type 
        operator()( const void* r ) const
        { 
            return fun( * static_cast<const Arg1*>( r ) );
        }
        typename result_of< Fun( Arg1, Arg2 ) >::type 
        operator()( const void* l, const void* r ) const
        { 
            return fun( * static_cast<const Arg1*>( l ), * static_cast<const Arg2*>( r ) );
        }
        
    private:
        Fun fun;   
    };
    template< class Fun, class Arg >
    inline void_ptr_indirect_fun<Fun,Arg> 
    make_void_ptr_indirect_fun( Fun f )
    {
        return void_ptr_indirect_fun<Fun,Arg>( f );
    }
         
} // namespace 'boost'