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

Class template functionN

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Reference

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

Class template functionN

boost::functionN — A set of generalized function pointers that can be used for callbacks or wrapping function objects.

Synopsis

// In header: <boost/function.hpp>
template<typename R, typename T1, typename T2, ..., typename TN> 
class functionN : public function_base {
public:
  // types
  typedef R  result_type;         
  typedef T1 argument_type;         // If N == 1
  typedef T1 first_argument_type;   // If N == 2
  typedef T2 second_argument_type;  // If N == 2
  typedef T1 arg1_type;           
  typedef T2 arg2_type;           
     .
     .
     .
  typedef TN argN_type;           
  // static constants
  static const int arity = N;
  // member classes/structs/unions
  // Lambda library support
  template<typename Args> 
  struct sig {
    // types
    typedef result_type type;
  };
  // construct/copy/destruct
  functionN();
  functionN(const functionN&);
  functionN(functionN&&);
  template<typename F> functionN(F);
  template<typename F, typename Allocator> functionN(F, Allocator);
  functionN& operator=(const functionN&);
  functionN& operator=(functionN&&);
  ~functionN();
  // modifiers
  void swap(const functionN&);
  void clear();
  // capacity
  bool empty() const;
  operator safe_bool() const;
  bool operator!() const;
  // target access
  template<typename Functor> Functor* target();
  template<typename Functor> const Functor* target() const;
  template<typename Functor> bool contains(const Functor&) const;
  const std::type_info& target_type() const;
  // invocation
  result_type operator()(arg1_type, arg2_type, ..., argN_type) const;
};
// specialized algorithms
template<typename T1, typename T2, ..., typename TN> 
  void swap(functionN<T1, T2, ..., TN>&, functionN<T1, T2, ..., TN>&);
// comparison operators
template<typename T1, typename T2, ..., typename TN, typename Functor> 
  bool operator==(const functionN<T1, T2, ..., TN>&, Functor);
template<typename T1, typename T2, ..., typename TN, typename Functor> 
  bool operator==(Functor, const functionN<T1, T2, ..., TN>&);
template<typename T1, typename T2, ..., typename TN, typename Functor> 
  bool operator==(const functionN<T1, T2, ..., TN>&, 
                  reference_wrapper<Functor>);
template<typename T1, typename T2, ..., typename TN, typename Functor> 
  bool operator==(reference_wrapper<Functor>, 
                  const functionN<T1, T2, ..., TN>&);
template<typename T1, typename T2, ..., typename TN, typename U1, typename U2, 
         ..., typename UN> 
  void operator==(const functionN<T1, T2, ..., TN>&, 
                  const functionN<U1, U2, ..., UN>&);
template<typename T1, typename T2, ..., typename TN, typename Functor> 
  bool operator!=(const functionN<T1, T2, ..., TN>&, Functor);
template<typename T1, typename T2, ..., typename TN, typename Functor> 
  bool operator!=(Functor, const functionN<T1, T2, ..., TN>&);
template<typename T1, typename T2, ..., typename TN, typename Functor> 
  bool operator!=(const functionN<T1, T2, ..., TN>&, 
                  reference_wrapper<Functor>);
template<typename T1, typename T2, ..., typename TN, typename Functor> 
  bool operator!=(reference_wrapper<Functor>, 
                  const functionN<T1, T2, ..., TN>&);
template<typename T1, typename T2, ..., typename TN, typename U1, typename U2, 
         ..., typename UN> 
  void operator!=(const functionN<T1, T2, ..., TN>&, 
                  const functionN<U1, U2, ..., UN>&);

Description

Классный шаблонФункция Nна самом деле представляет собой семейство родственных классовфункция0,функция1и т.д., вплоть до некоторого определяемого реализацией максимума. В этом контексте<N>относится к числу параметров.

functionN public construct/copy/destruct

  1. <
    functionN();
    >

    Постусловия:

    		<this->empty()>

    Броски:

    		Не буду бросать.
  2. <
    functionN(constfunctionN&f);
    >

    Пост-условия:

    		Содержит копию цели<f>, если она есть, или пуста, если<f.empty()>.

    Броски:

    		Не бросит, если не копирует цель<f>бросок.
  3. <
    functionN(functionN&&f);
    >

    Требуется:

    		совместимый компилятор C++11.

    Постусловия:

    		Переносит значение с<f>на<*this>. Если аргумент имеет свой функциональный объект, выделенный на кучу, его буфер будет назначен<*this>, оставляя аргумент пустым.

    Броски:

    		Не бросит, если аргумент не имеет своего функционального объекта, выделенного не на кучу и копирующего цель бросков<f>.
  4. <
    template<typenameF>functionN(Ff);
    >

    Требуется:

    		F — объект функции, который можно назвать из<this>.

    		<*this>нацелен на копию<f>, если<f>не пуст, или<this->empty()>, если<f>пуст.
  5. <
    template<typenameF,typenameAllocator>functionN(Ff,Allocatoralloc);
    >

    Требует:

    		F является функциональным объектом, вызываемым из<this>, Распределитель является Распределителем. Копирующий конструктор и разрушитель Аллокатора не должны выбрасывать.

    Пост-условия:

    		<*this>нацелены на копию<f>, если<f>не пуст, или<this->empty()>, если<f>пуст.

    Эффекты:

    		Если требуется выделение памяти, для выделения этой памяти будет использоваться данный распределитель (или его копия).
  6. <
    functionN&operator=(constfunctionN&f);
    >

    Пост-условия:

    		Если конструкция копии не бросает,<*this>нацелена на копию<f>цели, если она имеет одну, или пуста, если<f.empty()>. Если копировать конструкцию,<this->empty()>.
  7. <
    functionN&operator=(functionN&&f);
    >

    Требуется:

    		совместимый компилятор C++11.

    Постусловия:

    		Переместите значение от<f>к<*this>. Если аргумент имеет объект функции, выделенный на куче, его буфер будет назначен<*this>, оставляя аргумент пустым.

    Броски:

    		Не бросит, если аргумент не имеет своего функционального объекта, выделенного не на кучу и копирующего цель<f>бросков.
  8. <
    ~functionN();
    >

    Эффекты:

    		Если<!this->empty()>уничтожает цель этого.

functionN modifiers

  1. <
    voidswap(constfunctionN&f);
    >

    Эффекты:

    		Обмен целями<*this>и<f>
  2. <
    voidclear();
    >

    		это->пустой[]

functionN capacity

  1. <
    boolempty()const;
    >

    		<false>, если<this>имеет цель, и<true>в противном случае.

    Броски:

    		Не буду бросать.
  2. <
    operatorsafe_bool()const;
    >

    Возвращается:

    <safe_bool>, который оценивает<false>в булевом контексте, когда<this->empty()>и<true>иначе.

    Бросает:

    		Не бросит.
  3. <
    booloperator!()const;
    >

Возвращение:

<this->empty()>

Броски:

Не бросит.

functionN target access

  1. <
    template<typenameFunctor>Functor*target();
template<typenameFunctor>constFunctor*target()const;
    >

    Возвращение:

    		Если<this>сохраняет цель типа<Functor>, возвращает адрес цели. В противном случае возвращает указатель NULL.

    Бросает:

    		Не буду бросать.
  2. <
    template<typenameFunctor>boolcontains(constFunctor&f)const;
    >

    Возврат:

    		<true>, если<this->target<Functor>()>не является NULL и<function_equal(*(this->target<Functor>()), f)>
  3. <
    conststd::type_info&target_type()const;
    >

    Возврат:

    		<typeid>объекта целевой функции, или<typeid(void)>, если<this->empty()>.

    Бросок:

    		Не буду бросать.

functionN invocation

  1. <
    result_typeoperator()(arg1_typea1,arg2_typea2,...,argN_typeaN)const;
    >

    Эффекты:

    		<f(a1, a2, ..., aN)>, где<f>является целью<*this>

    Возврат:

    		, если<R>является<void>, ничего не возвращается; в противном случае возвращается обратное значение вызова<f>.

    Бросает:

    		<bad_function_call>, если<this->empty()>. В противном случае, возможно, через любое исключение, брошенное целевой функцией<f>.

functionN specialized algorithms

  1. <
    template<typenameT1,typenameT2,...,typenameTN>
 voidswap(functionN<T1,T2,...,TN>&f1,functionN<T1,T2,...,TN>&f2);
    >

    Эффекты:

    		<f1.swap(f2)>

functionN comparison operators

  1. <
    template<typenameT1,typenameT2,...,typenameTN,typenameFunctor>
 booloperator==(constfunctionN<T1,T2,...,TN>&f,Functorg);
template<typenameT1,typenameT2,...,typenameTN,typenameFunctor>
 booloperator==(Functorg,constfunctionN<T1,T2,...,TN>&f);
template<typenameT1,typenameT2,...,typenameTN,typenameFunctor>
 booloperator==(constfunctionN<T1,T2,...,TN>&f,
                  reference_wrapper<Functor>g);
template<typenameT1,typenameT2,...,typenameTN,typenameFunctor>
 booloperator==(reference_wrapper<Functor>g,
                 constfunctionN<T1,T2,...,TN>&f);
template<typenameT1,typenameT2,...,typenameTN,typenameU1,typenameU2,
        ...,typenameUN>
 voidoperator==(constfunctionN<T1,T2,...,TN>&f1,
                 constfunctionN<U1,U2,...,UN>&f2);
    >

    Возвращение:

    Правда, когда<f>хранит объект типа<Functor>и применяется одно из следующих условий:
    • <g>относится к типу<reference_wrapper<Functor>>и<f.target<Functor>() == g.get_pointer()>.
    • <g>не относится к типу<reference_wrapper<Functor>>и<function_equal(*(f.target<Functor>()), g)>.

    Примечания:

    <functionN>Объекты не равны.

    Обоснование:

    Конверсия<safe_bool>открывает лазейку, в которой два<functionN>экземпляра могут быть сопоставлены через<==>, хотя это невозможно реализовать. Неопределенный<void operator==>закрывает лазейку и обеспечивает ошибку компиляции или времени ссылки.

  2. <
    template<typenameT1,typenameT2,...,typenameTN,typenameFunctor>
 booloperator!=(constfunctionN<T1,T2,...,TN>&f,Functorg);
template<typenameT1,typenameT2,...,typenameTN,typenameFunctor>
 booloperator!=(Functorg,constfunctionN<T1,T2,...,TN>&f);
template<typenameT1,typenameT2,...,typenameTN,typenameFunctor>
 booloperator!=(constfunctionN<T1,T2,...,TN>&f,
                  reference_wrapper<Functor>g);
template<typenameT1,typenameT2,...,typenameTN,typenameFunctor>
 booloperator!=(reference_wrapper<Functor>g,
                 constfunctionN<T1,T2,...,TN>&f);
template<typenameT1,typenameT2,...,typenameTN,typenameU1,typenameU2,
        ...,typenameUN>
 voidoperator!=(constfunctionN<T1,T2,...,TN>&f1,
                 constfunctionN<U1,U2,...,UN>&f2);
    >

    Возвращение:

    		Верно, когда<f>не хранит объект типа<Functor>или хранит объект типа<Functor>и применяется одно из следующих условий:
    • <g>относится к типу<reference_wrapper<Functor>>и<f.target<Functor>() != g.get_pointer()>.
    • <g>не относится к типу<reference_wrapper<Functor>>и<!function_equal(*(f.target<Functor>()), g)>.

    Примечания:

    		 <functionN>Объекты не равны.

    Обоснование:

    		 Преобразование<safe_bool>открывает лазейку, при которой два<functionN>экземпляра могут быть сопоставлены через<!=>, хотя это не представляется возможным реализовать. Неопределенный<void operator!=>закрывает лазейку и обеспечивает ошибку компиляции или времени ссылки.
Copyright © 2001-2004 Douglas Gregor

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

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




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


:: Главная :: Reference ::

реклама

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

Время компиляции файла: 2024-08-30 08:47:00
2025-10-31 14:54:34/0.012312889099121/0