1. 程式人生 > >Boost中Core模組的ref用法

Boost中Core模組的ref用法

標頭檔案

boost/core/ref.hpp

作用

能夠將 基本資料型別及自定義類,進行 包裝,及解引用;還可以對函式進行 包裝,及解引用

主要API:boost::ref,boost::cref,boost::is_reference_wrapper,boost::unwrap_reference

主要巨集:BOOST_TEST_REF,BOOST_TEST_CREF

舉例

基本資料型別包裝

#include <boost/ref.hpp>
#include <boost/core/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/detail/workaround.hpp>

namespace {

template< typename T, typename U >
void ref_test(boost::reference_wrapper<U>)
{
    typedef typename boost::reference_wrapper<U>::type type;
    BOOST_STATIC_ASSERT((boost::core::is_same<U,type>::value));
    BOOST_STATIC_ASSERT((boost::core::is_same<T,type>::value));
}

} // namespace

int main()
{
    int i = 0;
    int& ri = i;

    int const ci = 0;
    int const& rci = ci;

    // 'ref/cref' functions test
    ref_test<int>(boost::ref(i));
    ref_test<int>(boost::ref(ri));
    ref_test<int const>(boost::ref(ci));
    ref_test<int const>(boost::ref(rci));
    
    return 0;
}

基本資料型別 const包裝

#include <boost/ref.hpp>
#include <boost/core/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/detail/workaround.hpp>

namespace {

template< typename T, typename U >
void ref_test(boost::reference_wrapper<U>)
{
    typedef typename boost::reference_wrapper<U>::type type;
    BOOST_STATIC_ASSERT((boost::core::is_same<U,type>::value));
    BOOST_STATIC_ASSERT((boost::core::is_same<T,type>::value));
}

} // namespace

int main()
{
    int i = 0;
    int& ri = i;

    int const ci = 0;
    int const& rci = ci;

    ref_test<int const>(boost::cref(i));
    ref_test<int const>(boost::cref(ri));
    ref_test<int const>(boost::cref(ci));
    ref_test<int const>(boost::cref(rci));

    return 0;
}

包裝型別 賦值

#include <boost/ref.hpp>
#include <boost/core/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/detail/workaround.hpp>

namespace {

template< typename T >
void assignable_test(T x)
{
    x = x;
}

} // namespace

int main()
{
    int i = 0;
    int& ri = i;

    int const ci = 0;
    int const& rci = ci;

    // test 'assignable' requirement
    assignable_test(boost::ref(i));
    assignable_test(boost::ref(ri));
    assignable_test(boost::cref(i));
    assignable_test(boost::cref(ci));
    assignable_test(boost::cref(rci));
 
    return 0;
}

包裝型別 判斷

#include <boost/ref.hpp>
#include <boost/core/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/detail/workaround.hpp>

namespace {

template< bool R, typename T >
void is_reference_wrapper_test(T)
{
    BOOST_STATIC_ASSERT(boost::is_reference_wrapper<T>::value == R);
}


} // namespace

int main()
{
    int i = 0;
    int& ri = i;

    int const ci = 0;
    int const& rci = ci;

    // 'is_reference_wrapper' test
    is_reference_wrapper_test<true>(boost::ref(i));
    is_reference_wrapper_test<true>(boost::ref(ri));
    is_reference_wrapper_test<true>(boost::cref(i));
    is_reference_wrapper_test<true>(boost::cref(ci));
    is_reference_wrapper_test<true>(boost::cref(rci));

    is_reference_wrapper_test<false>(i);
    is_reference_wrapper_test<false, int&>(ri);
    is_reference_wrapper_test<false>(ci);
    is_reference_wrapper_test<false, int const&>(rci);

    return 0;
}

包裝型別 解引用

#include <boost/ref.hpp>
#include <boost/core/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/detail/workaround.hpp>

namespace {

template< typename R, typename Ref >
void unwrap_reference_test(Ref)
{
    typedef typename boost::unwrap_reference<Ref>::type type;
    BOOST_STATIC_ASSERT((boost::core::is_same<R,type>::value));
}

} // namespace

int main()
{
    int i = 0;
    int& ri = i;

    int const ci = 0;
    int const& rci = ci;

    // 'unwrap_reference' test
    unwrap_reference_test<int>(boost::ref(i));
    unwrap_reference_test<int>(boost::ref(ri));
    unwrap_reference_test<int const>(boost::cref(i));
    unwrap_reference_test<int const>(boost::cref(ci));
    unwrap_reference_test<int const>(boost::cref(rci));

    unwrap_reference_test<int>(i);
    unwrap_reference_test<int>(ri);
    unwrap_reference_test<int>(ci);
    unwrap_reference_test<int>(rci);
    unwrap_reference_test<int&, int&>(i);
    unwrap_reference_test<int&, int&>(ri);
    unwrap_reference_test<int const&, int const&>(i);
    unwrap_reference_test<int const&, int const&>(ri);
    unwrap_reference_test<int const&, int const&>(ci);
    unwrap_reference_test<int const&, int const&>(rci);

    return 0;
}

普通引用測試

#include <boost/ref.hpp>
#include <boost/core/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/detail/workaround.hpp>

namespace {

template< typename R, typename Ref >
void cxx_reference_test(Ref)
{
    BOOST_STATIC_ASSERT((boost::core::is_same<R,Ref>::value));
}

} // namespace

int main()
{
    int i = 0;
    int& ri = i;

    int const ci = 0;
    int const& rci = ci;

    // ordinary references/function template arguments deduction test
    cxx_reference_test<int>(i);
    cxx_reference_test<int>(ri);
    cxx_reference_test<int>(ci);
    cxx_reference_test<int>(rci);

    cxx_reference_test<int&, int&>(i);
    cxx_reference_test<int&, int&>(ri);
    cxx_reference_test<int const&, int const&>(i);
    cxx_reference_test<int const&, int const&>(ri);
    cxx_reference_test<int const&, int const&>(ci);
    cxx_reference_test<int const&, int const&>(rci);

    return 0;
}

BOOST_TEST_REF及BOOST_TEST_CREF

#include <boost/ref.hpp>
#include <boost/core/lightweight_test.hpp>

#define BOOST_TEST_REF( x ) BOOST_TEST( &boost::ref( x ).get() == &x )
#define BOOST_TEST_CREF( x ) BOOST_TEST( &boost::cref( x ).get() == &x )

int main()
{
	int x1 = 1;
	int const x2 = 2;
	int volatile x3 = 3;
	int const volatile x4 = 4;

	BOOST_TEST_REF( x1 );
	BOOST_TEST_CREF( x1 );

	BOOST_TEST_REF( x2 );
	BOOST_TEST_CREF( x2 );

	BOOST_TEST_REF( x3 );
	BOOST_TEST_CREF( x3 );

	BOOST_TEST_REF( x4 );
	BOOST_TEST_CREF( x4 );

	return boost::report_errors();
}

函式的引用及解引用

#include <boost/ref.hpp>
#include <boost/detail/lightweight_test.hpp>


void f0()
{
}

void f1(int)
{
}

void f2(int, int)
{
}

void f3(int, int, int)
{
}

void f4(int, int, int, int)
{
}

void f5(int, int, int, int, int)
{
}

void f6(int, int, int, int, int, int)
{
}

void f7(int, int, int, int, int, int, int)
{
}

void f8(int, int, int, int, int, int, int, int)
{
}

void f9(int, int, int, int, int, int, int, int, int)
{
}

#define BOOST_TEST_REF( f ) BOOST_TEST( &boost::ref( f ).get() == &f )

int main()
{
    int v = 0;
    BOOST_TEST_REF( v );

    BOOST_TEST_REF( f0 );
    BOOST_TEST_REF( f1 );
    BOOST_TEST_REF( f2 );
    BOOST_TEST_REF( f3 );
    BOOST_TEST_REF( f4 );
    BOOST_TEST_REF( f5 );
    BOOST_TEST_REF( f6 );
    BOOST_TEST_REF( f7 );
    BOOST_TEST_REF( f8 );
    BOOST_TEST_REF( f9 );

    return boost::report_errors();
}

基本資料型別不支援自動引用及const 引用

}

void f1( boost::reference_wrapper< int const > )
{
}

int main()
{
    f( 1 ); // should fail
    f1( 1 ); // should fail
    
}

包裝引用類get函式

#include <boost/ref.hpp>
#include <boost/core/lightweight_test.hpp>

template<class T> void test( T const & t )
{
    {
        boost::reference_wrapper< T const > r = boost::ref( t );
        BOOST_TEST_EQ( &r.get(), &t );
    }

    {
        boost::reference_wrapper< T const > r = boost::cref( t );
        BOOST_TEST_EQ( &r.get(), &t );
    }
}

template<class T> void test_nonconst( T & t )
{
    {
        boost::reference_wrapper< T > r = boost::ref( t );
        BOOST_TEST_EQ( &r.get(), &t );
    }

    {
        boost::reference_wrapper< T const > r = boost::cref( t );
        BOOST_TEST_EQ( &r.get(), &t );
    }
}

int main()
{
    int x = 0;

    test( x );
    test( boost::ref( x ) );
    test( boost::cref( x ) );

    test_nonconst( x );

    {
        boost::reference_wrapper< int > r = boost::ref( x );
        test_nonconst( r );
    }

    {
        boost::reference_wrapper< int const > r = boost::cref( x );
        test_nonconst( r );
    }

    return boost::report_errors();
}

原始碼

namespace boost
{

#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )

    struct ref_workaround_tag {};

#endif

// reference_wrapper

/**
 @brief Contains a reference to an object of type `T`.

 `reference_wrapper` is primarily used to "feed" references to
 function templates (algorithms) that take their parameter by
 value. It provides an implicit conversion to `T&`, which
 usually allows the function templates to work on references
 unmodified.
*/
template<class T> class reference_wrapper
{
public:
    /**
     Type `T`.
    */
    typedef T type;

    /**
     Constructs a `reference_wrapper` object that stores a
     reference to `t`.

     @remark Does not throw.
    */
    BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}

#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )

    BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( boost::addressof( t ) ) {}

#endif

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
    /**
     @remark Construction from a temporary object is disabled.
    */
    BOOST_DELETED_FUNCTION(reference_wrapper(T&& t))
public:
#endif

    /**
     @return The stored reference.
     @remark Does not throw.
    */
    BOOST_FORCEINLINE operator T& () const { return *t_; }

    /**
     @return The stored reference.
     @remark Does not throw.
    */
    BOOST_FORCEINLINE T& get() const { return *t_; }

    /**
     @return A pointer to the object referenced by the stored
       reference.
     @remark Does not throw.
    */
    BOOST_FORCEINLINE T* get_pointer() const { return t_; }

private:

    T* t_;
};

// ref

/**
 @cond
*/
#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
#  define BOOST_REF_CONST
#else
#  define BOOST_REF_CONST const
#endif
/**
 @endcond
*/

/**
 @return `reference_wrapper<T>(t)`
 @remark Does not throw.
*/
template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t )
{
#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )

    return reference_wrapper<T>( t, ref_workaround_tag() );

#else

    return reference_wrapper<T>( t );

#endif
}

// cref

/**
 @return `reference_wrapper<T const>(t)`
 @remark Does not throw.
*/
template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t )
{
    return reference_wrapper<T const>(t);
}

#undef BOOST_REF_CONST

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

/**
 @cond
*/
#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
#  define BOOST_REF_DELETE
#else
#  define BOOST_REF_DELETE = delete
#endif
/**
 @endcond
*/

/**
 @remark Construction from a temporary object is disabled.
*/
template<class T> void ref(T const&&) BOOST_REF_DELETE;

/**
 @remark Construction from a temporary object is disabled.
*/
template<class T> void cref(T const&&) BOOST_REF_DELETE;

#undef BOOST_REF_DELETE

#endif

// is_reference_wrapper

/**
 @brief Determine if a type `T` is an instantiation of
 `reference_wrapper`.

 The value static constant will be true if the type `T` is a
 specialization of `reference_wrapper`.
*/
template<typename T> struct is_reference_wrapper
{
    BOOST_STATIC_CONSTANT( bool, value = false );
};

/**
 @cond
*/
template<typename T> struct is_reference_wrapper< reference_wrapper<T> >
{
    BOOST_STATIC_CONSTANT( bool, value = true );
};

#if !defined(BOOST_NO_CV_SPECIALIZATIONS)

template<typename T> struct is_reference_wrapper< reference_wrapper<T> const >
{
    BOOST_STATIC_CONSTANT( bool, value = true );
};

template<typename T> struct is_reference_wrapper< reference_wrapper<T> volatile >
{
    BOOST_STATIC_CONSTANT( bool, value = true );
};

template<typename T> struct is_reference_wrapper< reference_wrapper<T> const volatile >
{
    BOOST_STATIC_CONSTANT( bool, value = true );
};

#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)

/**
 @endcond
*/


// unwrap_reference

/**
 @brief Find the type in a `reference_wrapper`.

 The `typedef` type is `T::type` if `T` is a
 `reference_wrapper`, `T` otherwise.
*/
template<typename T> struct unwrap_reference
{
    typedef T type;
};

/**
 @cond
*/
template<typename T> struct unwrap_reference< reference_wrapper<T> >
{
    typedef T type;
};

#if !defined(BOOST_NO_CV_SPECIALIZATIONS)

template<typename T> struct unwrap_reference< reference_wrapper<T> const >
{
    typedef T type;
};

template<typename T> struct unwrap_reference< reference_wrapper<T> volatile >
{
    typedef T type;
};

template<typename T> struct unwrap_reference< reference_wrapper<T> const volatile >
{
    typedef T type;
};

#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)

/**
 @endcond
*/

// unwrap_ref

/**
 @return `unwrap_reference<T>::type&(t)`
 @remark Does not throw.
*/
template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t )
{
    return t;
}

// get_pointer

/**
 @cond
*/
template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r )
{
    return r.get_pointer();
}
/**
 @endcond
*/

} // namespace boost