Карта сайта Kansoftware
НОВОСТИУСЛУГИРЕШЕНИЯКОНТАКТЫ
Разработка программного обеспечения

Reference

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Chapter 23. Boost.Move

Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

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/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/move.hpp>
Header <boost/move/algo/move.hpp>
Header <boost/move/traits.hpp>
Header <boost/move/unique_ptr.hpp>
Header <boost/move/utility.hpp>
Header <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);
}
namespace boost {
  namespace movelib {
    template<typename RandIt, typename Compare> 
      void adaptive_merge(RandIt, RandIt, RandIt, Compare, 
                          typename iterator_traits< RandIt >::value_type * = 0, 
                          std::size_t = 0);
  }
}
namespace boost {
  namespace movelib {
    template<typename RandIt, typename Compare> 
      void adaptive_sort(RandIt, RandIt, Compare, 
                         typename iterator_traits< RandIt >::value_type * = 0, 
                         std::size_t = 0);
  }
}
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_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)
namespace boost {
  template<typename T> struct has_move_emulation_enabled;
  template<typename T> struct has_move_emulation_disabled;
}

Описывает дефолтный (политика разрушения)<unique_ptr>:<default_delete>.

namespace boost {
  namespace movelib {
    template<typename T> struct default_delete;
  }
}
namespace boost {
  template<typename It> class move_iterator;
  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> 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);
}
namespace boost {
  template<typename T> struct has_trivial_destructor_after_move;
  template<typename T> struct has_nothrow_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<operator <>, на необработанных указателях и других умных указателях обеспечивается строгий слабый заказ на практике.

  • присваивается из буквального 0 для компиляторов без нульпримера

  • <unique_ptr<T[]>>является конструируемым и присваиваемым из<unique_ptr<U[]>>, если cv-less T и cv-less U являются одним и тем же типом и T более квалифицирован, чем U

    .

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);
}
Copyright © 2008-2014 Ion Gaztanaga

Распространяется под лицензией Boost Software License, версия 1.0. (См. сопроводительный файл LICENSE_1_0.txt или копию по адресуhttp://www.boost.org/LICENSE_1_0.txt)

PrevUpHomeNext

Статья Reference раздела The Boost C++ Libraries BoostBook Documentation Subset Chapter 23. Boost.Move может быть полезна для разработчиков на c++ и boost.




Материалы статей собраны из открытых источников, владелец сайта не претендует на авторство. Там где авторство установить не удалось, материал подаётся без имени автора. В случае если Вы считаете, что Ваши права нарушены, пожалуйста, свяжитесь с владельцем сайта.


:: Главная :: Chapter 23. Boost.Move ::

реклама
©KANSoftWare (разработка программного обеспечения, создание программ, создание интерактивных сайтов), 2007
Top.Mail.Ru

Время компиляции файла: 2024-08-30 11:47:00
2025-05-19 17:07:46/0.010280132293701/1