boost-react-native-bundle

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> <title>Annex: Alternatives</title> <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> <meta name="generator" content="DocBook XSL Stylesheets V1.76.1"> <link rel="home" href="../index.html" title="Chapter 1. Boost.LocalFunction 1.0.0"> <link rel="up" href="../index.html" title="Chapter 1. Boost.LocalFunction 1.0.0"> <link rel="prev" href="examples.html" title="Examples"> <link rel="next" href="no_variadic_macros.html" title="Annex: No Variadic Macros"> </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="examples.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.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="no_variadic_macros.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> </div> <div class="section boost_localfunction_alternatives"> <div class="titlepage"><div><div><h2 class="title" style="clear: both"> <a name="boost_localfunction.alternatives"></a><a class="link" href="alternatives.html" title="Annex: Alternatives">Annex: Alternatives</a> </h2></div></div></div> This section compares the features offered by this library with similar features offered by C++ and by other libraries. <h4> <a name="boost_localfunction.alternatives.h0"></a> <a name="boost_localfunction.alternatives.features"></a><a class="link" href="alternatives.html#boost_localfunction.alternatives.features">Features</a> </h4> The following table compares local function features. <div class="informaltable"><table class="table"> <colgroup> <col> <col> <col> <col> <col> <col> </colgroup> <thead><tr> <th> Local Function Feature </th> <th> Boost.LocalFunction </th> <th> C++11 Lambda Function (Not C++03) </th> <th> Local Functor </th> <th> Global Functor (Not Local) </th> <th> Boost.Phoenix </th> </tr></thead> <tbody> <tr> <td> Can be defined locally </td> <td> Yes. </td> <td> Yes. </td> <td> Yes. </td> <td> No. Therefore this not really an alternative implementation of local functions but it is listed here just for comparison. </td> <td> Yes. </td> </tr> <tr> <td> Can be defined using C++ statement syntax </td> <td> Yes. Plus eventual compiler errors and debugging retain their usual meaning and format. </td> <td> Yes. Plus eventual compiler errors and debugging retain their usual meaning and format. </td> <td> Yes. Plus eventual compiler errors and debugging retain their usual meaning and format. </td> <td> Yes. Plus eventual compiler errors and debugging retain their usual meaning and format. </td> <td> No (it uses C++ <a href="http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Expression-template" target="_top">expression template</a> syntax). </td> </tr> <tr> <td> Can be defined within expressions </td> <td> No. It can be defined only within declarations. </td> <td> Yes (plus the local function can be unnamed). </td> <td> No. It can be defined only within declarations. </td> <td> No. It can be defined only within declarations. </td> <td> Yes (plus the local function can be unnamed). </td> </tr> <tr> <td> Can be passed as template parameter (e.g., to STL algorithms) </td> <td> Yes. The <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/standards" target="_top">C++03</a> standard does not allow to pass local types as template parameters (see <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm" target="_top">[N2657]</a>) but this library implements a "trick" to get around this limitation (see the <a class="link" href="implementation.html" title="Annex: Implementation">Implementation</a> section). </td> <td> Yes. </td> <td> No on <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/standards" target="_top">C++03</a> compilers (but yes on <a href="http://www.open-std.org/JTC1/SC22/WG21/" target="_top">C++11</a> compilers and some compilers like MSVC 8.0, see <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm" target="_top">[N2657]</a>). </td> <td> Yes. </td> <td> Yes. </td> </tr> <tr> <td> Access variables in scope </td> <td> Yes. The variable names are repeated in the function declaration so they can be bound by value, by constant value, by reference, and by constant reference (the object <code class="computeroutput">this</code> can also be bound using <code class="computeroutput">this_</code>). </td> <td> Yes. The variable names are repeated in the function declaration (plus there is a short-hand syntax to bind all variables in scope at once) so they can be bound by constant value and by reference (the object <code class="computeroutput">this</code> can also be bound). However, variables cannot be bound by constant references (see below). </td> <td> No. Programmers must manually program functor data members and explicitly specify their types to access variables in scope. </td> <td> No. Programmers must manually program functor data members and explicitly specify their types to access variables in scope. </td> <td> Yes. Variables in scope are accessible as usual within expressions (plus <code class="computeroutput">boost::phoenix::let</code> can be used to bind variables by constant reference). </td> </tr> <tr> <td> <a href="http://en.wikipedia.org/wiki/Type_polymorphism#Parametric_polymorphism" target="_top">Polymorphic</a> in the function parameter type </td> <td> No (local functions cannot be function templates). </td> <td> No (<a href="http://www.open-std.org/JTC1/SC22/WG21/" target="_top">C++11</a> lambdas cannot be function templates). </td> <td> No (local classes cannot have member function templates). </td> <td> Yes. </td> <td> Yes. </td> </tr> </tbody> </table></div> C++11 Lambda Function <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11 lambda functions</a> have most of the features of this library plus some additional feature (see also the example in the <a class="link" href="../index.html#boost_localfunction.introduction" title="Introduction">Introduction</a> section): <div class="itemizedlist"><ul class="itemizedlist" type="disc"> <li class="listitem"> <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11 lambda functions</a> can be defined within expressions while this library local functions can only be defined at declaration scope. </li> <li class="listitem"> <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11 lambda functions</a> are only supported by the <a href="http://www.open-std.org/JTC1/SC22/WG21/" target="_top">C++11</a> standard so they are not supported by all C++ compilers. This library local functions can be programmed also on <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/standards" target="_top">C++03</a> compilers (and they have performances comparable to <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11 lambda functions</a> on <a href="http://www.open-std.org/JTC1/SC22/WG21/" target="_top">C++11</a> compilers). </li> <li class="listitem"> <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11 lambda functions</a> do not allow to bind variables in scope by constant reference. Because a variable cannot be bound by constant reference, <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11 lambda functions</a> can bind a variable by constant only if the variable is <code class="computeroutput">CopyConstructible</code> and the binding requires a (potentially expensive) extra copy operation. Constant reference binding is instead supported by this library. </li> <li class="listitem"> <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11 lambda functions</a> do not allow to bind data members selectively without binding also the object <code class="computeroutput">this</code> while this library local functions can bind either selected data members or the entire object <code class="computeroutput">this</code> (using <code class="computeroutput">this_</code>). </li> <li class="listitem"> <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11 lambda functions</a> provide a short-hand syntax to bind all variables in scope at once (<code class="computeroutput">&</code> or <code class="computeroutput">=</code>) while this library local function always require to bind variables naming them one-by-one. </li> </ul></div> For example, for non-copyable objects (see also <a href="../../../example/noncopyable_cxx11_lambda_error.cpp" target="_top"><code class="literal">noncopyable_cxx11_lambda_error.cpp</code></a> and <a href="../../../example/noncopyable_local_function.cpp" target="_top"><code class="literal">noncopyable_local_function.cpp</code></a>): <div class="informaltable"><table class="table"> <colgroup> <col> <col> </colgroup> <thead><tr> <th> C++11 Lambda Function </th> <th> Boost.LocalFunction </th> </tr></thead> <tbody><tr> <td> <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">struct n: boost::noncopyable { int i; n(int _i): i(_i) {} }; int main(void) { n x(-1); auto f = [x](void) { // Error: x is non-copyable, but if assert(x.i == -1); // bind `&x` then `x` is not constant. }; f(); return 0; } </pre> </td> <td> <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">struct n: boost::noncopyable { int i; n(int _i): i(_i) {} }; BOOST_TYPEOF_REGISTER_TYPE(n) // Register for `bind& x` below. int main(void) { n x(-1); void BOOST_LOCAL_FUNCTION(const bind& x) { // OK: No copy assert(x.i == -1); // and constant. } BOOST_LOCAL_FUNCTION_NAME(f) f(); return 0; } </pre> </td> </tr></tbody> </table></div> Or, for objects with expensive copy operations (see also <a href="../../../example/expensive_copy_cxx11_lambda.cpp" target="_top"><code class="literal">expensive_copy_cxx11_lambda.cpp</code></a> and <a href="../../../example/expensive_copy_local_function.cpp" target="_top"><code class="literal">expensive_copy_local_function.cpp</code></a>): <div class="informaltable"><table class="table"> <colgroup> <col> <col> </colgroup> <thead><tr> <th> C++11 Lambda Function </th> <th> Boost.LocalFunction </th> </tr></thead> <tbody><tr> <td> <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">struct n { int i; n(int _i): i(_i) {} n(n const& x): i(x.i) { // Some time consuming copy operation. for (unsigned i = 0; i < 10000; ++i) std::cout << '.'; } }; int main(void) { n x(-1); auto f = [x]() { // Problem: Expensive copy, but if bind assert(x.i == -1); // by `&x` then `x` is not constant. }; f(); return 0; } </pre> </td> <td> <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">struct n { int i; n(int _i): i(_i) {} n(n const& x): i(x.i) { // Some time consuming copy operation. for (unsigned i = 0; i < 10000; ++i) std::cout << '.'; } }; BOOST_TYPEOF_REGISTER_TYPE(n) // Register for `bind& x` below. int main(void) { n x(-1); void BOOST_LOCAL_FUNCTION(const bind& x) { // OK: No copy expensive assert(x.i == -1); // copy but constant. } BOOST_LOCAL_FUNCTION_NAME(f) f(); return 0; } </pre> </td> </tr></tbody> </table></div> When constant binding functionality is needed for <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11 lambda functions</a>, the best alternative might be to bind an extra local variable declared constant and initialized to the original variable (for example, see constant blocks implemented with <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11 lambda functions</a> in the <a class="link" href="examples.html" title="Examples">Examples</a> section). Local Functor The following example compares local functions with C++ local functors (see also <a href="../../../example/add_local_functor.cpp" target="_top"><code class="literal">add_local_functor.cpp</code></a> and <a href="../../../test/add.cpp" target="_top"><code class="literal">add.cpp</code></a>): <div class="informaltable"><table class="table"> <colgroup> <col> <col> </colgroup> <thead><tr> <th> Local Functor </th> <th> Boost.LocalFunction </th> </tr></thead> <tbody><tr> <td> <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">int main(void) { int sum = 0, factor = 10; struct local_add { // Unfortunately, boilerplate code to program the class. local_add(int& _sum, int _factor): sum(_sum), factor(_factor) {} inline void operator()(int num) { // Body uses C++ statement syntax. sum += factor * num; } private: // Unfortunately, cannot bind so repeat variable types. int& sum; // Access `sum` by reference. const int factor; // Make `factor` constant. } add(sum, factor); add(1); int nums[] = {2, 3}; // Unfortunately, cannot pass as template parameter to `std::for_each`. for(size_t i = 0; i < 2; ++i) add(nums[i]); BOOST_TEST(sum == 60); return boost::report_errors(); } </pre> </td> <td> <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">int main(void) { // Some local scope. int sum = 0, factor = 10; // Variables in scope to bind. void BOOST_LOCAL_FUNCTION(const bind factor, bind& sum, int num) { sum += factor * num; } BOOST_LOCAL_FUNCTION_NAME(add) add(1); // Call the local function. int nums[] = {2, 3}; std::for_each(nums, nums + 2, add); // Pass it to an algorithm. BOOST_TEST(sum == 60); // Assert final summation value. return boost::report_errors(); } </pre> </td> </tr></tbody> </table></div> Global Functor The following example compares local functions with C++ global functors (see also <a href="../../../example/add_global_functor.cpp" target="_top"><code class="literal">add_global_functor.cpp</code></a> and <a href="../../../test/add.cpp" target="_top"><code class="literal">add.cpp</code></a>): <div class="informaltable"><table class="table"> <colgroup> <col> <col> </colgroup> <thead><tr> <th> Global Functor </th> <th> Boost.LocalFunction </th> </tr></thead> <tbody><tr> <td> <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">// Unfortunately, cannot be defined locally (so not a real alternative). struct global_add { // Unfortunately, boilerplate code to program the class. global_add(int& _sum, int _factor): sum(_sum), factor(_factor) {} inline void operator()(int num) { // Body uses C++ statement syntax. sum += factor * num; } private: // Unfortunately, cannot bind so repeat variable types. int& sum; // Access `sum` by reference. const int factor; // Make `factor` constant. }; int main(void) { int sum = 0, factor = 10; global_add add(sum, factor); add(1); int nums[] = {2, 3}; std::for_each(nums, nums + 2, add); // Passed as template parameter. BOOST_TEST(sum == 60); return boost::report_errors(); } </pre> </td> <td> <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">int main(void) { // Some local scope. int sum = 0, factor = 10; // Variables in scope to bind. void BOOST_LOCAL_FUNCTION(const bind factor, bind& sum, int num) { sum += factor * num; } BOOST_LOCAL_FUNCTION_NAME(add) add(1); // Call the local function. int nums[] = {2, 3}; std::for_each(nums, nums + 2, add); // Pass it to an algorithm. BOOST_TEST(sum == 60); // Assert final summation value. return boost::report_errors(); } </pre> </td> </tr></tbody> </table></div> However, note that global functors do not allow to define the function locally so they are not a real alternative implementation of local functions. Boost.Phoenix The following example compares local functions with <a href="http://www.boost.org/libs/phoenix" target="_top">Boost.Phoenix</a> (see also <a href="../../../example/add_phoenix.cpp" target="_top"><code class="literal">add_phoenix.cpp</code></a> and <a href="../../../test/add.cpp" target="_top"><code class="literal">add.cpp</code></a>): <div class="informaltable"><table class="table"> <colgroup> <col> <col> </colgroup> <thead><tr> <th> Boost.Phoenix </th> <th> Boost.LocalFunction </th> </tr></thead> <tbody><tr> <td> <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">int main(void) { using boost::phoenix::let; using boost::phoenix::local_names::_f; using boost::phoenix::cref; using boost::phoenix::ref; using boost::phoenix::arg_names::_1; int sum = 0, factor = 10; int nums[] = {1, 2, 3}; // Passed to template, `factor` by constant, and defined in expression. std::for_each(nums, nums + 3, let(_f = cref(factor))[ // Unfortunately, body cannot use C++ statement syntax. ref(sum) += _f * _1, _1 // Access `sum` by reference. ]); BOOST_TEST(sum == 60); return boost::report_errors(); } </pre> </td> <td> <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting">int main