boost-react-native-bundle

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> <title>TR1 By Subject</title> <link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css"> <meta name="generator" content="DocBook XSL Stylesheets V1.78.1"> <link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset"> <link rel="up" href="../boost_tr1.html" title="Chapter 31. Boost.TR1"> <link rel="prev" href="config.html" title="Configuration"> <link rel="next" href="header_list.html" title="TR1 By Header"> </head> <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> <table cellpadding="2" width="100%"><tr> <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td> <td align="center"><a href="../../../index.html">Home</a></td> <td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td> <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> <td align="center"><a href="../../../more/index.htm">More</a></td> </tr></table> <hr> <div class="spirit-nav"> <a accesskey="p" href="config.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../boost_tr1.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="header_list.html"><img src="../../../doc/src/images/next.png" alt="Next"></a> </div> <div class="section"> <div class="titlepage"><div><div><h2 class="title" style="clear: both"> <a name="boost_tr1.subject_list"></a><a class="link" href="subject_list.html" title="TR1 By Subject">TR1 By Subject</a> </h2></div></div></div> <div class="toc"><dl class="toc"> <dt><a href="subject_list.html#boost_tr1.subject_list.ref">Reference Wrappers.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.ptrs">Smart Pointers.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.result_of">Class template result_of.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.mem_fn">Function template mem_fn.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.bind">Function Object Binders.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.function">Polymorphic function wrappers.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.type_traits">Type Traits.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.random">Random Number Generators and Distributions.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.tuple">Tuples.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.utility">Tuple Interface to std::pair.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.array">Fixed Size Array.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.hash">Hash Function Objects.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.regex">Regular Expressions.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.complex">Complex Number Algorithm Overloads.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.complex_trig">Complex Number Additional Algorithms.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.unordered_set">Unordered Associative Set (Hash Table).</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.unordered_map">Unordered Associative Map (Hash Table).</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.special">Mathematical Special Functions.</a></dt> <dt><a href="subject_list.html#boost_tr1.subject_list.c99_special">C99 Mathematical Special Functions.</a></dt> </dl></div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="boost_tr1.subject_list.ref"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.ref" title="Reference Wrappers.">Reference Wrappers.</a> </h3></div></div></div> <pre class="programlisting">#include <boost/tr1/functional.hpp> </pre> or <pre class="programlisting">#include <functional> </pre> The Ref library is a small library that is useful for passing references to function templates (algorithms) that would usually take copies of their arguments. It defines the class template <code class="computeroutput">reference_wrapper<T></code>, and the two functions <code class="computeroutput">ref</code> and <code class="computeroutput">cref</code> that return instances of <code class="computeroutput">reference_wrapper<T></code>. <a href="../../../doc/html/ref.html" target="_top">Refer to Boost.Bind for more information.</a> <pre class="programlisting">namespace std { namespace tr1 { template <class T> class reference_wrapper; template <class T> reference_wrapper<T> ref(T&); template <class T> reference_wrapper<const T> cref(const T&); template <class T> reference_wrapper<T> ref(reference_wrapper<T>); template <class T> reference_wrapper<const T> cref(reference_wrapper<T>); } // namespace tr1 } // namespace std </pre> Configuration: <a href="../../../libs/config/index.html" target="_top">Boost.Config</a> should (automatically) define the macro BOOST_HAS_TR1_REFERENCE_WRAPPER if your standard library implements this part of TR1. Standard Conformity: The Boost version of this this component does not currently support function call invocation (2.1.2.4), or derivation from std::unary_function or std::binary_function (2.1.2 paragraphs 3 and 4). The Boost version is not implicitly convertible to T& as the TR requires. </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="boost_tr1.subject_list.ptrs"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.ptrs" title="Smart Pointers.">Smart Pointers.</a> </h3></div></div></div> <pre class="programlisting">#include <boost/tr1/memory.hpp> </pre> or <pre class="programlisting">#include <memory> </pre> The <code class="computeroutput">shared_ptr</code> class template stores a pointer to a dynamically allocated object, typically with a C++ new-expression. The object pointed to is guaranteed to be deleted when the last <code class="computeroutput">shared_ptr</code> pointing to it is destroyed or reset. For more information refer to the <a href="../../../libs/smart_ptr/shared_ptr.htm" target="_top">shared_ptr</a> and <a href="../../../libs/smart_ptr/weak_ptr.htm" target="_top">weak_ptr</a> documentation. <pre class="programlisting">namespace std { namespace tr1 { class bad_weak_ptr; // [2.2.3] Class template shared_ptr template<class T> class shared_ptr; // [2.2.3.6] shared_ptr comparisons template<class T, class U> bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b); template<class T, class U> bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b); template<class T, class U> bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b); // [2.2.3.8] shared_ptr specialized algorithms template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b); // [2.2.3.9] shared_ptr casts template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r); template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r); template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r); // [2.2.3.7] shared_ptr I/O template<class E, class T, class Y> basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p); // [2.2.3.10] shared_ptr get_deleter template<class D, class T> D * get_deleter(shared_ptr<T> const& p); // [2.2.4] Class template weak_ptr template<class T> class weak_ptr; // [2.2.4.6] weak_ptr comparison template<class T, class U> bool operator<(weak_ptr<T> const& a, weak_ptr<U> const& b); // [2.2.4.7] weak_ptr specialized algorithms template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b); // [2.2.5] Class enable_shared_from_this template<class T> class enable_shared_from_this; } // namespace tr1 } // namespace std </pre> Configuration: <a href="../../../libs/config/index.html" target="_top">Boost.Config</a> should (automatically) define the macro BOOST_HAS_TR1_SHARED_PTR if your standard library implements this part of TR1. Standard Conformity: There are no known deviations from the standard when using the Boost version of this component. </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="boost_tr1.subject_list.result_of"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.result_of" title="Class template result_of.">Class template result_of.</a> </h3></div></div></div> <pre class="programlisting">#include <boost/tr1/functional.hpp> </pre> or <pre class="programlisting">#include <functional> </pre> The class template <code class="computeroutput">result_of</code> helps determine the type of a call expression. Given an lvalue <code class="computeroutput">f</code> of type <code class="computeroutput">F</code> and lvalues <code class="computeroutput">t1</code>, <code class="computeroutput">t2, ..., tN</code> of types <code class="computeroutput">T1, T2, ..., TN</code>, respectively, the type <code class="computeroutput">result_of<F(T1, T2, ..., TN)>::type</code> defines the result type of the expression <code class="computeroutput">f(t1, t2, ...,tN)</code>. The implementation permits the type <code class="computeroutput">F</code> to be a function pointer, function reference, member function pointer, or class type. For more information <a href="../../../libs/utility/utility.htm#result_of" target="_top">refer to the Boost.Utility documentation.</a> <pre class="programlisting">namespace std { namespace tr1 { template <class T> struct result_of { typedef unspecified type; }; } // namespace tr1 } // namespace std </pre> Configuration: <a href="../../../libs/config/index.html" target="_top">Boost.Config</a> should (automatically) define the macro BOOST_HAS_TR1_RESULT_OF if your standard library implements this part of TR1. Standard Conformity: No known problems. </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="boost_tr1.subject_list.mem_fn"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.mem_fn" title="Function template mem_fn.">Function template mem_fn.</a> </h3></div></div></div> <pre class="programlisting">#include <boost/tr1/functional.hpp> </pre> or <pre class="programlisting">#include <functional> </pre> <code class="computeroutput">std::tr1::mem_fn</code> is a generalization of the standard functions <code class="computeroutput">std::mem_fun</code> and <code class="computeroutput">std::mem_fun_ref</code>. It supports member function pointers with more than one argument, and the returned function object can take a pointer, a reference, or a smart pointer to an object instance as its first argument. <code class="computeroutput">mem_fn</code> also supports pointers to data members by treating them as functions taking no arguments and returning a (const) reference to the member. For more information refer to the <a href="../../../libs/bind/mem_fn.html" target="_top">Boost.Mem_fn documentation</a>. <pre class="programlisting">namespace std { namespace tr1 { template <class R, class T> unspecified mem_fn(R T::* pm); } // namespace tr1 } // namespace std </pre> Configuration: <a href="../../../libs/config/index.html" target="_top">Boost.Config</a> should (automatically) define the macro BOOST_HAS_TR1_MEM_FN if your standard library implements this part of TR1. Standard Conformity: The Boost implementation does not produce functors that inherit from <code class="computeroutput">std::unary_function</code> or <code class="computeroutput">std::binary_function</code>, nor does it function correctly with pointers to volatile member functions (these should be extremely rare in practice however). </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="boost_tr1.subject_list.bind"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.bind" title="Function Object Binders.">Function Object Binders.</a> </h3></div></div></div> <pre class="programlisting">#include <boost/tr1/functional.hpp> </pre> or <pre class="programlisting">#include <functional> </pre> <code class="computeroutput">std::tr1::bind</code> is a generalization of the standard functions <code class="computeroutput">std::bind1st</code> and <code class="computeroutput">std::bind2nd</code>. It supports arbitrary function objects, functions, function pointers, and member function pointers, and is able to bind any argument to a specific value or route input arguments into arbitrary positions. <code class="computeroutput">bind</code> does not place any requirements on the function object; in particular, it does not need the <code class="computeroutput">result_type</code>, <code class="computeroutput">first_argument_type</code> and <code class="computeroutput">second_argument_type</code> standard typedefs. For more information refer to the <a href="../../../libs/bind/bind.html" target="_top">Boost.Bind documentation</a>. <pre class="programlisting">namespace std { namespace tr1 { // [3.6] Function object binders template<class T> struct is_bind_expression; template<class T> struct is_placeholder; template<class F, class T1, ..., class Tn > unspecified bind(F f, T1 t1, ..., Tn tn ); template<class R, class F, class T1, ..., class Tn > unspecified bind(F f, T1 t1, ..., Tn tn ); namespace placeholders { // M is the implementation-defined number of placeholders extern unspecified _1; extern unspecified _2; . . . extern unspecified _M; } } // namespace tr1 } // namespace std </pre> Configuration: <a href="../../../libs/config/index.html" target="_top">Boost.Config</a> should (automatically) define the macro BOOST_HAS_TR1_BIND if your standard library implements this part of TR1. Standard Conformity: The traits classes <code class="computeroutput">is_placeholder</code> and <code class="computeroutput">is_bind_expression</code> are not supported by the Boost implementation. The named return value syntax isn't supported if the object being bound is a function pointer, for example: <pre class="programlisting">std::tr1::bind(&my_proc, arg1, arg2 /* etc */); // works OK. std::tr1::bind<double>(&my_proc, arg1, arg2 /* etc */); // causes compiler error. std::tr1::bind<double>(my_function_object, arg1, arg2 /* etc */); // works OK. </pre> On the other hand, the Boost implementation does work with pointers to overloaded functions, and optionally with function pointers with non-standard calling conventions. </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="boost_tr1.subject_list.function"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.function" title="Polymorphic function wrappers.">Polymorphic function wrappers.</a> </h3></div></div></div> <pre class="programlisting">#include <boost/tr1/functional.hpp> </pre> or <pre class="programlisting">#include <functional> </pre> The polymorphic function wrappers are a family of class templates that may be used as a generalized callback mechanism. A polymorphic function wrapper shares features with function pointers, in that both define a call interface (for example a function taking two integer arguments and returning a floating-point value) through which some arbitrary code may be called. However a polymorphic function wrapper can call any callable object with a compatible call signature, this could be a function pointer, or it could be a function object produced by std::tr1::bind, or some other mechanism. For more information see the <a href="../../../doc/html/function.html" target="_top">Boost.Function documentation</a>. <pre class="programlisting">namespace std { namespace tr1 { // [3.7] polymorphic function wrappers class bad_function_call; template<class Function> class function; template<class Function> void swap(function<Function>&, function<Function>&); template<class Function1, class Function2> void operator==(const function<Function1>&, const function<Function2>&); template<class Function1, class Function2> void operator!=(const function<Function1>&, const function<Function2>&); template <class Function> bool operator==(const function<Function>&, unspecified-null-pointer-type ); template <class Function> bool operator==(unspecified-null-pointer-type , const function<Function>&); template <class Function> bool operator!=(const function<Function>&, unspecified-null-pointer-type ); template <class Function> bool operator!=(unspecified-null-pointer-type , const function<Function>&); } // namespace tr1 } // namespace std </pre> Configuration: <a href="../../../libs/config/index.html" target="_top">Boost.Config</a> should (automatically) define the macro BOOST_HAS_TR1_FUNCTION if your standard library implements this part of TR1. Standard Conformity: The Boost version of <code class="computeroutput">std::tr1::function</code> lacks the member function <code class="computeroutput">target_type()</code> and does not inherit from <code class="computeroutput">std::unary_function</code> or <code class="computeroutput">std::binary_function</code> when applicable. The member function target() can only access pointer-to-member targets when they have been wrapped in mem_fn. </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="boost_tr1.subject_list.type_traits"></a><a class="link" href="subject_list.html#boost_tr1.subject_list.type_traits" title="Type Traits.">Type Traits.</a> </h3></div></div></div> <pre class="programlisting">#include <boost/tr1/type_traits.hpp> </pre> or <pre class="programlisting">#include <type_traits> </pre> Type traits enable generic code to access the fundamental properties of a type, to determine the relationship between two types, or to transform one type into another related type. For more information refer to the <a href="../../../libs/type_traits/index.html" target="_top">Boost.Type_traits documentation</a>. <pre class="programlisting">namespace std { namespace tr1