boost-react-native-bundle

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> <title>Main features</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="../container.html" title="Chapter 8. Boost.Container"> <link rel="prev" href="../container.html" title="Chapter 8. Boost.Container"> <link rel="next" href="exception_handling.html" title="Boost.Container and C++ exceptions"> </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="../container.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../container.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="exception_handling.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="container.main_features"></a><a class="link" href="main_features.html" title="Main features">Main features</a> </h2></div></div></div> <div class="toc"><dl class="toc"> <dt><a href="main_features.html#container.main_features.move_emplace">Efficient insertion</a></dt> <dt><a href="main_features.html#container.main_features.containers_of_incomplete_types">Containers of Incomplete Types</a></dt> <dt><a href="main_features.html#container.main_features.scary_iterators">SCARY iterators</a></dt> <dt><a href="main_features.html#container.main_features.other_features">Other features</a></dt> </dl></div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="container.main_features.move_emplace"></a><a class="link" href="main_features.html#container.main_features.move_emplace" title="Efficient insertion">Efficient insertion</a> </h3></div></div></div> <div class="toc"><dl class="toc"> <dt><a href="main_features.html#container.main_features.move_emplace.move_containers">Move-aware containers</a></dt> <dt><a href="main_features.html#container.main_features.move_emplace.emplace">Emplace: Placement insertion</a></dt> </dl></div> Move semantics and placement insertion are two features brought by C++11 containers that can have a very positive impact in your C++ applications. Boost.Container implements both techniques both for C++11 and C++03 compilers. <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="container.main_features.move_emplace.move_containers"></a><a class="link" href="main_features.html#container.main_features.move_emplace.move_containers" title="Move-aware containers">Move-aware containers</a> </h4></div></div></div> All containers offered by Boost.Container can store movable-only types and actual requirements for <code class="computeroutput">value_type</code> depend on each container operations. Following C++11 requirements even for C++03 compilers, many operations now require movable or default constructible types instead of just copy constructible types. Containers themselves are also movable, with no-throw guarantee if allocator or predicate (if present) copy operations are no-throw. This allows high performance operations when transferring data between vectors. Let's see an example: <pre class="programlisting">#include <boost/container/vector.hpp> #include <boost/move/utility_core.hpp> #include <cassert> //Non-copyable class class non_copyable { BOOST_MOVABLE_BUT_NOT_COPYABLE(non_copyable) public: non_copyable(){} non_copyable(BOOST_RV_REF(non_copyable)) {} non_copyable& operator=(BOOST_RV_REF(non_copyable)) { return *this; } }; int main () { using namespace boost::container; //Store non-copyable objects in a vector vector<non_copyable> v; non_copyable nc; v.push_back(boost::move(nc)); assert(v.size() == 1); //Reserve no longer needs copy-constructible v.reserve(100); assert(v.capacity() >= 100); //This resize overload only needs movable and default constructible v.resize(200); assert(v.size() == 200); //Containers are also movable vector<non_copyable> v_other(boost::move(v)); assert(v_other.size() == 200); assert(v.empty()); return 0; } </pre> </div> <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="container.main_features.move_emplace.emplace"></a><a class="link" href="main_features.html#container.main_features.move_emplace.emplace" title="Emplace: Placement insertion">Emplace: Placement insertion</a> </h4></div></div></div> All containers offered by Boost.Container implement placement insertion, which means that objects can be built directly into the container from user arguments without creating any temporary object. For compilers without variadic templates support placement insertion is emulated up to a finite (10) number of arguments. Expensive to move types are perfect candidates emplace functions and in case of node containers (<code class="computeroutput"><a class="link" href="../boost/container/list.html" title="Class template list">list</a></code>, <code class="computeroutput"><a class="link" href="../boost/container/set.html" title="Class template set">set</a></code>, ...) emplace allows storing non-movable and non-copyable types in containers! Let's see an example: <pre class="programlisting">#include <boost/container/list.hpp> #include <cassert> //Non-copyable and non-movable class class non_copy_movable { non_copy_movable(const non_copy_movable &); non_copy_movable& operator=(const non_copy_movable &); public: non_copy_movable(int = 0) {} }; int main () { using namespace boost::container; //Store non-copyable and non-movable objects in a list list<non_copy_movable> l; non_copy_movable ncm; //A new element will be built calling non_copy_movable(int) contructor l.emplace(l.begin(), 0); assert(l.size() == 1); //A new element will be value initialized l.emplace(l.begin()); assert(l.size() == 2); return 0; } </pre> </div> </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="container.main_features.containers_of_incomplete_types"></a><a class="link" href="main_features.html#container.main_features.containers_of_incomplete_types" title="Containers of Incomplete Types">Containers of Incomplete Types</a> </h3></div></div></div> <div class="toc"><dl class="toc"> <dt><a href="main_features.html#container.main_features.containers_of_incomplete_types.recursive_containers">Recursive containers</a></dt> <dt><a href="main_features.html#container.main_features.containers_of_incomplete_types.type_erasure">Type Erasure</a></dt> </dl></div> Incomplete types allow <a href="http://en.wikipedia.org/wiki/Type_erasure" target="_top">type erasure </a> and <a href="http://en.wikipedia.org/wiki/Recursive_data_type" target="_top">recursive data types</a>, and C and C++ programmers have been using it for years to build complex data structures, like tree structures where a node may have an arbitrary number of children. What about standard containers? Containers of incomplete types have been under discussion for a long time, as explained in Matt Austern's great article (<a href="http://drdobbs.com/184403814" target="_top">The Standard Librarian: Containers of Incomplete Types</a>): “Unlike most of my columns, this one is about something you can't do with the C++ Standard library: put incomplete types in one of the standard containers. This column explains why you might want to do this, why the standardization committee banned it even though they knew it was useful, and what you might be able to do to get around the restriction.” “In 1997, shortly before the C++ Standard was completed, the standardization committee received a query: Is it possible to create standard containers with incomplete types? It took a while for the committee to understand the question. What would such a thing even mean, and why on earth would you ever want to do it? The committee eventually worked it out and came up with an answer to the question. (Just so you don't have to skip ahead to the end, the answer is "no.") But the question is much more interesting than the answer: it points to a useful, and insufficiently discussed, programming technique. The standard library doesn't directly support that technique, but the two can be made to coexist.” “In a future revision of C++, it might make sense to relax the restriction on instantiating standard library templates with incomplete types. Clearly, the general prohibition should stay in place - instantiating templates with incomplete types is a delicate business, and there are too many classes in the standard library where it would make no sense. But perhaps it should be relaxed on a case-by-case basis, and <code class="computeroutput">vector</code> looks like a good candidate for such special-case treatment: it's the one standard container class where there are good reasons to instantiate it with an incomplete type and where Standard Library implementors want to make it work. As of today, in fact, implementors would have to go out of their way to prohibit it!” C++11 standard is also cautious about incomplete types and STL: “17.6.4.8 Other functions (...) 2. the effects are undefined in the following cases: (...) In particular - if an incomplete type (3.9) is used as a template argument when instantiating a template component, unless specifically allowed for that component”. Fortunately all Boost.Container containers except <code class="computeroutput"><a class="link" href="../boost/container/static_vector.html" title="Class template static_vector">static_vector</a></code> and <code class="computeroutput"><a class="link" href="../boost/container/basic_string.html" title="Class template basic_string">basic_string</a></code> are designed to support incomplete types. <code class="computeroutput"><a class="link" href="../boost/container/static_vector.html" title="Class template static_vector">static_vector</a></code> is special because it statically allocates memory for <code class="computeroutput">value_type</code> and this requires complete types and <code class="computeroutput"><a class="link" href="../boost/container/basic_string.html" title="Class template basic_string">basic_string</a></code> implements Small String Optimization which also requires complete types. Boost.Container containers supporting incomplete types also support instantiating iterators to those incomplete elements. <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="container.main_features.containers_of_incomplete_types.recursive_containers"></a><a class="link" href="main_features.html#container.main_features.containers_of_incomplete_types.recursive_containers" title="Recursive containers">Recursive containers</a> </h4></div></div></div> Most Boost.Container containers can be used to define recursive containers: <pre class="programlisting">#include <boost/container/vector.hpp> #include <boost/container/stable_vector.hpp> #include <boost/container/deque.hpp> #include <boost/container/list.hpp> #include <boost/container/map.hpp> #include <boost/container/string.hpp> using namespace boost::container; struct data { int i_; //A vector holding still undefined class 'data' vector<data> v_; vector<data>::iterator vi_; //A stable_vector holding still undefined class 'data' stable_vector<data> sv_; stable_vector<data>::iterator svi_; //A stable_vector holding still undefined class 'data' deque<data> d_; deque<data>::iterator di_; //A list holding still undefined 'data' list<data> l_; list<data>::iterator li_; //A map holding still undefined 'data' map<data, data> m_; map<data, data>::iterator mi_; friend bool operator <(const data &l, const data &r) { return l.i_ < r.i_; } }; struct tree_node { string name; string value; //children nodes of this node list<tree_node> children_; list<tree_node>::iterator selected_child_; }; int main() { //a container holding a recursive data type stable_vector<data> sv; sv.resize(100); //Let's build a tree based in //a recursive data type tree_node root; root.name = "root"; root.value = "root_value"; root.children_.resize(7); root.selected_child_ = root.children_.begin(); return 0; } </pre> </div> <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="container.main_features.containers_of_incomplete_types.type_erasure"></a><a class="link" href="main_features.html#container.main_features.containers_of_incomplete_types.type_erasure" title="Type Erasure">Type Erasure</a> </h4></div></div></div> Containers of incomplete types are useful to break header file dependencies and improve compilation types. With Boost.Container, you can write a header file defining a class with containers of incomplete types as data members, if you carefully put all the implementation details that require knowing the size of the <code class="computeroutput">value_type</code> in your implementation file: In this header file we define a class (<code class="computeroutput">MyClassHolder)</code> that holds a <code class="computeroutput">vector</code> of an incomplete type (<code class="computeroutput">MyClass</code>) that it's only forward declared. <pre class="programlisting">#include <boost/container/vector.hpp> //MyClassHolder.h //We don't need to include "MyClass.h" //to store vector<MyClass> class MyClass; class MyClassHolder { public: void AddNewObject(const MyClass &o); const MyClass & GetLastObject() const; private: ::boost::container::vector<MyClass> vector_; }; </pre> Then we can define <code class="computeroutput">MyClass</code> in its own header file. <pre class="programlisting">//MyClass.h class MyClass { private: int value_; public: MyClass(int val = 0) : value_(val){} friend bool operator==(const MyClass &l, const MyClass &r) { return l.value_ == r.value_; } //... }; </pre> And include it only in the implementation file of <code class="computeroutput">MyClassHolder</code> <pre class="programlisting">//MyClassHolder.cpp #include "MyClassHolder.h" //In the implementation MyClass must be a complete //type so we include the appropriate header #include "MyClass.h" void MyClassHolder::AddNewObject(const MyClass &o) { vector_.push_back(o); } const MyClass & MyClassHolder::GetLastObject() const { return vector_.back(); } </pre> Finally, we can just compile, link, and run! <pre class="programlisting">//Main.cpp #include "MyClassHolder.h" #include "MyClass.h" #include <cassert> int main() { MyClass mc(7); MyClassHolder myclassholder; myclassholder.AddNewObject(mc); return myclassholder.GetLastObject() == mc ? 0 : 1; } </pre> </div> </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="container.main_features.scary_iterators"></a><a class="link" href="main_features.html#container.main_features.scary_iterators" title="SCARY iterators">SCARY iterators</a> </h3></div></div></div> The paper N2913, titled <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2913.pdf%2c" target="_top">SCARY Iterator Assignment and Initialization</a>, proposed a requirement that a standard container's iterator types have no dependency on any type argument apart from the container's <code class="computeroutput">value_type</code>, <code class="computeroutput">difference_type</code>, <code class="computeroutput">pointer type</code>, and <code class="computeroutput">const_pointer</code> type. In particular, according to the proposal, the types of a standard container's iterators should not depend on the container's <code class="computeroutput">key_compare</code>, <code class="computeroutput">hasher</code>, <code class="computeroutput">key_equal</code>, or <code class="computeroutput">allocator</code> types. That paper demonstrated that SCARY operations were crucial to the performant implementation of common design patterns using STL components. It showed that implementations that support SCARY operations reduce object code bloat by eliminating redundant specializations of iterator and algorithm templates. Boost.Container containers implement SCARY iterators so the iterator type of a container is only dependent on the <code class="computeroutput">allocator_traits<allocator_type>::pointer</code> type (the pointer type of the <code class="computeroutput">value_type</code> to be inserted in the container). Reference types and all other typedefs are deduced from the pointer type using the C++11 <code class="computeroutput">pointer_traits</code> utility. This leads to lower code bloat in algorithms and classes templated on iterators. </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="container.main_features.other_features"></a><a class="link" href="main_features.html#container.main_features.other_features" title="Other features">Other features</a> </h3></div></div></div> <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"> Default constructors don't allocate memory which improves performance and usually implies a no-throw guarantee (if predicate's or allocator's default constructor doesn't throw). </li> <li class="listitem"> Small string optimization for <code class="computeroutput"><a class="link" href="../boost/container/basic_string.html" title="Class template basic_string">basic_string</a></code>, with an internal buffer of 11/23 bytes (32/64 bit systems) without increasing the usual <code class="computeroutput">sizeof</code> of the string (3 words). </li> <li class="listitem"> <code class="computeroutput">[multi]set/map</code> containers are size optimized embedding the color bit of the red-black tree nodes in the parent pointer. </li> <li class="listitem"> <code class="computeroutput">[multi]set/map</code> containers use no recursive functions so stack problems are avoided. </li> </ul></div> </div> </div> <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> <td align="left"></td> <td align="right"><div class="copyright-footer">Copyright © 2009-2013 Ion Gaztanaga Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) </div></td> </tr></table> <hr> <div class="spirit-nav"> <a accesskey="p" href="../container.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../container.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="exception_handling.html"><img src="../../../doc/src/images/next.png" alt="Next"></a> </div> </body> </html>