Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Reference

Header <boost/move/adl_move_swap.hpp>
Header <boost/move/algo/adaptive_merge.hpp>
Header <boost/move/algo/adaptive_sort.hpp>
Header <boost/move/algo/predicate.hpp>
Header <boost/move/algo/unique.hpp>
Header <boost/move/algorithm.hpp>
Header <boost/move/core.hpp>
Header <boost/move/default_delete.hpp>
Header <boost/move/iterator.hpp>
Header <boost/move/make_unique.hpp>
Header <boost/move/algo/move.hpp>
Header <boost/move/move.hpp>
Header <boost/move/traits.hpp>
Header <boost/move/unique_ptr.hpp>
Header <boost/move/utility.hpp>
Header <boost/move/utility_core.hpp>

  template<typename T>  (, );
  template<typename ForwardIt1, typename ForwardIt2> 
     (, , );
  template<typename BidirIt1, typename BidirIt2> 
     ( first1,  last1, 
                                            last2);
  template<typename ForwardIt1, typename ForwardIt2> 
     ( a,  b);
}

  
    template<typename RandIt, typename Compare> 
       (, , , , 
                           = , 
                           = );
  }
}

  
    template<typename RandIt, typename RandRawIt, typename Compare> 
       (, , , , 
                         );
    template<typename RandIt, typename Compare> 
       ( first,  last,  comp);
  }
}

  
    template<typename Comp> struct antistable;

    template<typename Comp> class inverse;
    template<typename Comp> class negate;
    template<typename Comp>  ( comp);
    template<typename Comp>  ( comp);
  }
}

  
    template<typename ForwardIterator, typename BinaryPredicate> 
       
      (, , );
  }
}

  template<typename I, typename F> 
     ( f,  l,  r,  = );
  template<typename I, typename F> 
     ( f,  l,  r,  = );
  template<typename I, typename F>  (, , );
  template<typename I, typename F>  (, , );
}

This header implements macros to define movable classes and move-aware functions


BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)
BOOST_COPYABLE_AND_MOVABLE(TYPE)
BOOST_RV_REF(TYPE)
BOOST_RV_REF_BEG
BOOST_RV_REF_END
BOOST_RV_REF_BEG_IF_CXX11
BOOST_RV_REF_END_IF_CXX11
BOOST_COPY_ASSIGN_REF(TYPE)
BOOST_FWD_REF(TYPE)
BOOST_MOVE_RET(RET_TYPE, REF)
BOOST_MOVE_BASE(BASE_TYPE, ARG)
BOOST_MOVE_TO_LV(ARG)

  template<typename T> struct has_move_emulation_disabled;
  template<typename T> struct has_move_emulation_enabled;
}

Describes the default deleter (destruction policy) of unique_ptr: default_delete.


  
    template<typename T> struct default_delete;
  }
}

  template<typename C> class back_move_insert_iterator;
  template<typename C> class front_move_insert_iterator;
  template<typename C> class move_insert_iterator;
  template<typename It> class move_iterator;
  template<typename It> move_iterator<  ();
  template<typename C> back_move_insert_iterator<  ();
  template<typename C> 
    front_move_insert_iterator<  ();
  template<typename C> 
     (, );
}

Defines "make_unique" functions, which are factories to create instances of unique_ptr depending on the passed arguments.

This header can be a bit heavyweight in C++03 compilers due to the use of the preprocessor library, that's why it's a a separate header from unique_ptr.hpp


  
    template<typename T,  Args> 
      unique_ptr<  ();
    template<typename T,  Args> 
      unique_ptr<  ();
    template<typename T> unique_ptr<  ();
    template<typename T> unique_ptr<  ();
    template<typename T> unique_ptr<  ();
    template<typename T> unique_ptr<  ();
    template<typename T> unique_ptr<  ();
    template<typename T> 
      unique_ptr<  ();
    template<typename T,  Args>  ();
    template<typename T,  Args> 
       ();
    template<typename T,  Args> 
       ();
    template<typename T,  Args> 
       ();
  }
}

  template<typename I, typename O>  (, , );
  template<typename I, typename O>  (, , );
  template<typename I, typename F>  (, , );
}

A general library header that includes the rest of top-level headers.


  template<typename T> struct has_nothrow_move;
  template<typename T> struct has_trivial_destructor_after_move;
}

Describes the smart pointer unique_ptr, a drop-in replacement for std::unique_ptr, usable also from C++03 compilers.

Main differences from std::unique_ptr to avoid heavy dependencies, specially in C++03 compilers:

  • operator < uses pointer operator < instead of std::less<common_type>. This avoids dependencies on std::common_type and std::less (<type_traits>/<functional> headers). In C++03 this avoid pulling Boost.Typeof and other cascading dependencies. As in all Boost platforms operator < on raw pointers and other smart pointers provides strict weak ordering in practice this should not be a problem for users.

  • assignable from literal 0 for compilers without nullptr

  • unique_ptr<T[]> is constructible and assignable from unique_ptr<U[]> if cv-less T and cv-less U are the same type and T is more CV qualified than U.


  
    template<typename T, typename D = default_delete<> class unique_ptr;
    template<typename T, typename D> 
       (unique_ptr< , unique_ptr< );
    template<typename T1, typename D1, typename T2, typename D2> 
       (unique_ptr< , 
                      unique_ptr< );
    template<typename T1, typename D1, typename T2, typename D2> 
       (unique_ptr< , 
                      unique_ptr< );
    template<typename T1, typename D1, typename T2, typename D2> 
       (unique_ptr< , 
                     unique_ptr< );
    template<typename T1, typename D1, typename T2, typename D2> 
       (unique_ptr< , 
                      unique_ptr< );
    template<typename T1, typename D1, typename T2, typename D2> 
       (unique_ptr< , 
                     unique_ptr< );
    template<typename T1, typename D1, typename T2, typename D2> 
       (unique_ptr< , 
                      unique_ptr< );
    template<typename T, typename D> 
       (unique_ptr< , );
    template<typename T, typename D> 
       (, unique_ptr< );
    template<typename T, typename D> 
       (unique_ptr< , );
    template<typename T, typename D> 
       (, unique_ptr< );
    template<typename T, typename D> 
       (unique_ptr< , );
    template<typename T, typename D> 
       (, unique_ptr< );
    template<typename T, typename D> 
       (unique_ptr< , );
    template<typename T, typename D> 
       (, unique_ptr< );
    template<typename T, typename D> 
       (unique_ptr< , );
    template<typename T, typename D> 
       (, unique_ptr< );
    template<typename T, typename D> 
       (unique_ptr< , );
    template<typename T, typename D> 
       (, unique_ptr< );
  }
}

This header includes core utilities from <boost/move/utility_core.hpp> and defines some more advanced utilities such as:


  template<typename T> 
     
    ();
}

This header defines core utilities to ease the development of move-aware functions. This header minimizes dependencies from other libraries.


  template<typename T> struct enable_move_utility_emulation;
  template<typename T>  ();
  template<typename T>  ();
  template<typename T> 
     ();
}

PrevUpHomeNext