Boost C++ 库

……这是全球最受推崇、设计最精良的 C++ 库项目之一。 — Herb Sutter 和 Andrei Alexandrescu, C++ Coding Standards

参考 - Boost C++ 函数库
PrevUpHomeNext

参考

头文件 <boost/move/adl_move_swap.hpp>
头文件 <boost/move/algo/adaptive_merge.hpp>
头文件 <boost/move/algo/adaptive_sort.hpp>
头文件 <boost/move/algo/predicate.hpp>
头文件 <boost/move/algo/unique.hpp>
头文件 <boost/move/algorithm.hpp>
头文件 <boost/move/core.hpp>
头文件 <boost/move/default_delete.hpp>
头文件 <boost/move/iterator.hpp>
头文件 <boost/move/make_unique.hpp>
头文件 <boost/move/algo/move.hpp>
头文件 <boost/move/move.hpp>
头文件 <boost/move/traits.hpp>
头文件 <boost/move/unique_ptr.hpp>
头文件 <boost/move/utility.hpp>
头文件 <boost/move/utility_core.hpp>
namespace boost {
  template<typename T> void adl_move_swap(T &, T &);
  template<typename ForwardIt1, typename ForwardIt2> 
    ForwardIt2 adl_move_swap_ranges(ForwardIt1, ForwardIt1, ForwardIt2);
  template<typename BidirIt1, typename BidirIt2> 
    BidirIt2 adl_move_swap_ranges_backward(BidirIt1 first1, BidirIt1 last1, 
                                           BidirIt2 last2);
  template<typename ForwardIt1, typename ForwardIt2> 
    void adl_move_iter_swap(ForwardIt1 a, ForwardIt2 b);
}
namespace boost {
  namespace movelib {
    template<typename RandIt, typename Compare> 
      void adaptive_merge(RandIt, RandIt, RandIt, Compare, 
                          typename iterator_traits< RandIt >::value_type * = 0, 
                          typename iter_size< RandIt >::type = 0);
  }
}
namespace boost {
  namespace movelib {
    template<typename RandIt, typename RandRawIt, typename Compare> 
      void adaptive_sort(RandIt, RandIt, Compare, RandRawIt, 
                         typename iter_size< RandIt >::type);
    template<typename RandIt, typename Compare> 
      void adaptive_sort(RandIt first, RandIt last, Compare comp);
  }
}
namespace boost {
  namespace movelib {
    template<typename Comp> struct antistable;

    template<typename Comp> class inverse;
    template<typename Comp> class negate;
    template<typename Comp> Comp unantistable(Comp comp);
    template<typename Comp> Comp unantistable(antistable< Comp > comp);
  }
}
namespace boost {
  namespace movelib {
    template<typename ForwardIterator, typename BinaryPredicate> 
      ForwardIterator 
      unique(ForwardIterator, ForwardIterator, BinaryPredicate);
  }
}
namespace boost {
  template<typename I, typename F> 
    F uninitialized_copy_or_move(I f, I l, F r, unspecified = 0);
  template<typename I, typename F> 
    F copy_or_move(I f, I l, F r, unspecified = 0);
  template<typename I, typename F> F uninitialized_copy_or_move(I, I, F);
  template<typename I, typename F> F copy_or_move(I, I, F);
}

头文件 <boost/move/core.hpp>

此头文件实现了用于定义可移动类和移动感知函数的宏

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)
namespace boost {
  template<typename T> struct has_move_emulation_disabled;
  template<typename T> struct has_move_emulation_enabled;
}

描述了 unique_ptr 的默认删除器（销毁策略）：default_delete。

namespace boost {
  namespace movelib {
    template<typename T> struct default_delete;
  }
}
namespace boost {
  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< It > make_move_iterator(const It &);
  template<typename C> back_move_insert_iterator< C > back_move_inserter(C &);
  template<typename C> 
    front_move_insert_iterator< C > front_move_inserter(C &);
  template<typename C> 
    move_insert_iterator< C > move_inserter(C &, typename C::iterator);
}

定义了“make_unique”函数，它们是工厂，用于根据传入的参数创建 unique_ptr 实例。

由于使用了预处理器库，此头文件在 C++03 编译器中可能会有些沉重，这就是为什么它是一个独立于 unique_ptr.hpp 的单独头文件。

namespace boost {
  namespace movelib {
    template<typename T, class... Args> 
      unique_ptr< T > make_unique(Args &&...);
    template<typename T, class... Args> 
      unique_ptr< T > make_unique_nothrow(Args &&...);
    template<typename T> unique_ptr< T > make_unique_definit();
    template<typename T> unique_ptr< T > make_unique_nothrow_definit();
    template<typename T> unique_ptr< T > make_unique(std::size_t);
    template<typename T> unique_ptr< T > make_unique_nothrow(std::size_t);
    template<typename T> unique_ptr< T > make_unique_definit(std::size_t);
    template<typename T> 
      unique_ptr< T > make_unique_nothrow_definit(std::size_t);
    template<typename T, class... Args> unspecified make_unique(Args &&);
    template<typename T, class... Args> 
      unspecified make_unique_definit(Args &&);
    template<typename T, class... Args> 
      unspecified make_unique_nothrow(Args &&);
    template<typename T, class... Args> 
      unspecified make_unique_nothrow_definit(Args &&);
  }
}
namespace boost {
  template<typename I, typename O> O move(I, I, O);
  template<typename I, typename O> O move_backward(I, I, O);
  template<typename I, typename F> F uninitialized_move(I, I, F);
}

头文件 <boost/move/move.hpp>

一个通用的库头文件，包含了其他顶级头文件。

namespace boost {
  template<typename T> struct has_nothrow_move;
  template<typename T> struct has_trivial_destructor_after_move;
}

描述了智能指针 unique_ptr，它是 std::unique_ptr 的即插即用替代品，也可以在 C++03 编译器中使用。

与 std::unique_ptr 的主要区别在于避免了繁重的依赖，尤其是在 C++03 编译器中。

  • operator < 使用指针 operator < 而不是 std::less<common_type>。这避免了对 std::common_type 和 std::less（<type_traits>/<functional> 头文件）的依赖。在 C++03 中，这避免了引入 Boost.Typeof 和其他级联依赖。与所有 Boost 平台一样，原始指针和其他智能指针上的 operator < 在实践中提供了严格的弱排序，这对于用户来说不应该是一个问题。

  • 对于没有 nullptr 的编译器，可从字面量 0 赋值

  • unique_ptr<T[]> 可以从 unique_ptr<U[]> 构建和赋值，前提是无 cv 的 T 和无 cv 的 U 是同一类型，并且 T 比 U 具有更多的 cv 限定。

namespace boost {
  namespace movelib {
    template<typename T, typename D = default_delete<T> > class unique_ptr;
    template<typename T, typename D> 
      void swap(unique_ptr< T, D > &, unique_ptr< T, D > &);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator==(const unique_ptr< T1, D1 > &, 
                      const unique_ptr< T2, D2 > &);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator!=(const unique_ptr< T1, D1 > &, 
                      const unique_ptr< T2, D2 > &);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator<(const unique_ptr< T1, D1 > &, 
                     const unique_ptr< T2, D2 > &);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator<=(const unique_ptr< T1, D1 > &, 
                      const unique_ptr< T2, D2 > &);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator>(const unique_ptr< T1, D1 > &, 
                     const unique_ptr< T2, D2 > &);
    template<typename T1, typename D1, typename T2, typename D2> 
      bool operator>=(const unique_ptr< T1, D1 > &, 
                      const unique_ptr< T2, D2 > &);
    template<typename T, typename D> 
      bool operator==(const unique_ptr< T, D > &, std::nullptr_t);
    template<typename T, typename D> 
      bool operator==(std::nullptr_t, const unique_ptr< T, D > &);
    template<typename T, typename D> 
      bool operator!=(const unique_ptr< T, D > &, std::nullptr_t);
    template<typename T, typename D> 
      bool operator!=(std::nullptr_t, const unique_ptr< T, D > &);
    template<typename T, typename D> 
      bool operator<(const unique_ptr< T, D > &, std::nullptr_t);
    template<typename T, typename D> 
      bool operator<(std::nullptr_t, const unique_ptr< T, D > &);
    template<typename T, typename D> 
      bool operator>(const unique_ptr< T, D > &, std::nullptr_t);
    template<typename T, typename D> 
      bool operator>(std::nullptr_t, const unique_ptr< T, D > &);
    template<typename T, typename D> 
      bool operator<=(const unique_ptr< T, D > &, std::nullptr_t);
    template<typename T, typename D> 
      bool operator<=(std::nullptr_t, const unique_ptr< T, D > &);
    template<typename T, typename D> 
      bool operator>=(const unique_ptr< T, D > &, std::nullptr_t);
    template<typename T, typename D> 
      bool operator>=(std::nullptr_t, const unique_ptr< T, D > &);
  }
}

此头文件包含了来自 <boost/move/utility_core.hpp> 的核心实用工具，并定义了一些更高级的实用工具，例如：

namespace boost {
  template<typename T> 
    rvalue_reference_or_const_lvalue_reference 
    move_if_noexcept(input_reference);
}

此头文件定义了核心实用工具，以简化移动感知函数的开发。此头文件最大限度地减少了对其他库的依赖。

namespace boost {
  template<typename T> struct enable_move_utility_emulation;
  template<typename T> rvalue_reference move(input_reference);
  template<typename T> output_reference forward(input_reference);
  template<typename T> 
    output_reference move_if_not_lvalue_reference(input_reference);
}
版权所有 © 2008-2024 Ion Gaztanaga

根据 Boost 软件许可证版本 1.0 发布。（参见随附文件 LICENSE_1_0.txt 或在 https://boost.ac.cn/LICENSE_1_0.txt 复制）

PrevUpHomeNext