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

Class template variant

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 variant

boost::variant — Safe, generic, stack-based discriminated union container.

Synopsis

// In header: <boost/variant/variant.hpp>
template<typename T1, typename T2 = unspecified, ..., 
         typename TN = unspecified> 
class variant {
public:
  // types
  typedef unspecified types;
  // construct/copy/destruct
  variant();
  variant(const variant &);
  variant(variant &&);
  template<typename T> variant(T &);
  template<typename T> variant(const T &);
  template<typename T> variant(T &&);
  template<typename U1, typename U2, ..., typename UN> 
    variant(variant<U1, U2, ..., UN> &);
  template<typename U1, typename U2, ..., typename UN> 
    variant(const variant<U1, U2, ..., UN> &);
  template<typename U1, typename U2, ..., typename UN> 
    variant(variant<U1, U2, ..., UN> &&);
  ~variant();
  // modifiers
  void swap(variant &);
  variant & operator=(const variant &);
  variant & operator=(variant &&);
  template<typename T> variant & operator=(const T &);
  template<typename T> variant & operator=(T &&);
  // queries
  int which() const;
  bool empty() const;
  const std::type_info & type() const;
  // relational
  bool operator==(const variant &) const;
  template<typename U> void operator==(const U &) const;
  bool operator!=(const variant &) const;
  template<typename U> void operator!=(const U &) const;
  bool operator<(const variant &) const;
  template<typename U> void operator<(const U &) const;
  bool operator>(const variant &) const;
  template<typename U> void operator>(const U &) const;
  bool operator<=(const variant &) const;
  template<typename U> void operator<=(const U &) const;
  bool operator>=(const variant &) const;
  template<typename U> void operator>=(const U &) const;
};

Description

Шаблон класса<variant>(вдохновленный одноименным классом Андрея АлександрескуAle01A)]) является эффективным,рекурсивно-способным, ограниченным дискриминируемым типом союзных значений, способным содержать любой тип значений (либо POD, либо non-POD). Он поддерживает конструкцию из любого типа кабриолета в один из его ограниченных типов или из источника<variant>, ограниченные типы которого каждый кабриолет в один из ограниченных типов назначения<variant>. Кроме того, через<apply_visitor><variant>поддерживает проверенное время компиляции, безопасное посещение типа; и через<get>,<variant>поддерживает проверенное время выполнения, безопасное извлечение значения типа.

Примечания:

  • Ограниченные типы<variant>выставляются через вложенный типдеф<types>, который представляет собой MPL-совместимую последовательность, содержащую набор типов, которые должны обрабатываться любымпосетителем<variant>.
  • Все члены<variant>удовлетворяют, по крайней мере, базовой гарантии безопасности исключения. То есть все операции на<variant>остаются определенными даже после того, как предыдущие операции потерпели неудачу.
  • Каждый тип, указанный в качестве шаблонного аргумента<variant>, должен соответствовать требованиям концепцииBoundedType.
  • Каждый тип, указанный в качестве шаблонного аргумента<variant>, должен отличаться после удаления отборочных материалов. Так, например, как<variant<int, int>>, так и<variant<int, const int>>имеют неопределенное поведение.
  • Соответствующие реализации<variant>должны допускать как минимум десять типов в качестве шаблонных аргументов. Точное количество разрешенных аргументов раскрывается макропроцессором<BOOST_VARIANT_LIMIT_TYPES>. (См.<make_variant_over>для средства определения ограниченных типов<variant>элементами MPL или совместимой последовательности, таким образом преодолевая это ограничение.)

variant public construct/copy/destruct

  1. <
    variant();
    >

    Требуется:

    		Первый ограниченный тип<variant>(то есть<T1>) должен соответствовать требованиям.Конструкция по умолчанию[20.1.4].

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

    		Содержание<*this>является значением по умолчанию первого ограниченного типа (т.е.<T1>.

    Б Броски:

    Броски:

    		 May fail with any exceptions arising from the default constructor of T1.
    [ORIG_END] -->
  2. <
    variant(constvariant&other);
    >

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

    		Содержание<*this>является копией содержания<other>.

    Броски:

    Броски:

    		 May fail with any exceptions arising from the copy constructor of other's contained type.
    [ORIG_END] -->
  3. variant(variant && other);

    Requires:

    		 C++11 compatible compiler.

    Postconditions:

    		 Content of *this is move constructed from the content of other.

    Броски:

    		 May fail with any exceptions arising from the move constructor of other's contained type. 
  4. template<typename T> variant(T & operand);

    Requires:

    		 T must be unambiguously convertible to one of the bounded types (i.e., T1, T2, etc.).

    Postconditions:

    		 Content of *this is the best conversion of operand to one of the bounded types, as determined by standard overload resolution rules.

    Броски:

    		 May fail with any exceptions arising from the conversion of operand to one of the bounded types.
  5. <
    template<typenameT>variant(constT&operand);
    >

    Примечания:

    		Такая же семантика, как и у предыдущего конструктора, но позволяет строить из временного.
  6. <
    template<typenameT>variant(T&&operand);
    >

    Требуется:

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

    Примечания:

    		Такая же семантика, как и у предыдущего конструктора, но позволяет перемещать конструкцию, если<operand>является rvalue.
  7. типовое имя ,   ,   ,  ,     ,   ,    и ,   ,   ,   ,   ,
, U1, T2, ... T2, ... T2, ... Пост-условия:2> В противном случае содержание *это является наилучшим преобразованием содержимого operand в один из ограниченных типов, как определено стандартными правилами разрешения перегрузки.

Броски:

<-- [ORIG_BEGIN]

Броски:

Броски:

 If variant<U1, U2, ..., UN> is itself one of the bounded types, then may fail with any exceptions arising from the copy constructor of variant<U1, U2, ..., UN>. Otherwise, may fail with any exceptions arising from the conversion of the content of operand to one of the bounded types.
[ORIG_END] -->
  • <
    template<typenameU1,typenameU2,...,typenameUN>
 variant(constvariant<U1,U2,...,UN>&operand);
    >

    Примечания:

    		Такая же семантика, как и у предыдущего конструктора, но позволяет строить из временного.
  • <
    template<typenameU1,typenameU2,...,typenameUN>
 variant(variant<U1,U2,...,UN>&&operand);
    >

    Требуется:

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

    Примечания:

    		Такая же семантика, как и у предыдущего конструктора, но позволяет перемещать конструкцию.
  • <
    ~variant();
    >

    Эффекты:

    [!-- [ORIG_BEGIN]

    Эффекты:

    Эффекты:

    		 Destroys the content of *this.

    Броски:

    		 Will not throw.
    [ORIG_END] -->

    • variant modifiers

    1. void swap(variant & other);

      Requires:

      		 Каждый ограниченный тип должен соответствовать требованиям концепции MoveAssignable.

      Эффекты:

      		 Interchanges the content of *this and other.

      Броски:

      		 If the contained type of other is the same as the contained type of *this, then may fail with any exceptions arising from the swap of the contents of *this and other. Otherwise, may fail with any exceptions arising from either of the move or copy constructors of the contained types. Also, in the event of insufficient memory, may fail with std::bad_alloc (why?). 
    2. variant & operator=(const variant & rhs);

      Requires:

      		 Every bounded type must fulfill the requirements of the Assignable concept.

      Эффекты:

      		 If the contained type of rhs is the same as the contained type of *this, then assigns the content of rhs into the content of *this. Otherwise, makes the content of *this a copy of the content of rhs, destroying the previous content of *this.

      Броски:

      		 If the contained type of rhs is the same as the contained type of *this, then may fail with any exceptions arising from the assignment of the content of rhs into the content *this. Otherwise, may fail with any exceptions arising from the copy constructor of the contained type of rhs. Also, in the event of insufficient memory, may fail with std::bad_alloc (why?).
    3. <
      variant&operator=(variant&&rhs);
      >

      Требуется:

      • С++11 совместимый компилятор.
      • Каждый ограниченный тип должен соответствовать требованиям концепции MoveAssignable.

      Эффекты:

      		 Если содержащееся содержание<rhs>совпадает с содержащимся типом<*this>, то перемещение присваивает содержание<rhs>содержанию<*this>. В противном случае, перемещайте конструкции<*this>, используя содержимое<rhs>, разрушая предыдущее содержимое<*this>.

      Броски:

      		 Если содержащийся тип<rhs>является таким же, как содержащийся тип<*this>, то может не сработать с любыми исключениями, вытекающими из назначения перемещения содержания<rhs>в содержание<*this>. В противном случае, может не сработать с любыми исключениями, вытекающими из перемещения конструктора содержащегося типа<rhs>. Кроме того, в случае недостаточной памяти может потерпеть неудачу с<std::bad_alloc>почему?.
    4. <
      template<typenameT>variant&operator=(constT&rhs);
      >

      Требуется:

      • <T>должен быть однозначно конвертируемым в один из ограниченных типов (т.е.<T1>,<T2>и т.д.).
      • Каждый ограниченный тип должен соответствовать требованиям Подлежащей применению концепции.

      Эффекты:

      		 Если<*this>содержит<T>, то<rhs>присваивает содержанию<*this>. В противном случае содержание<*this>становится наилучшим преобразованием<rhs>в один из ограниченных типов, что определяется стандартными правилами разрешения перегрузок, разрушающими прежнее содержание<*this>.

      Броски:

      		 Если<*this>содержит<T>, то может не работать с любыми исключениями, вытекающими из назначения<rhs>в содержание<*this>. В противном случае может произойти сбой с любыми исключениями, вытекающими из преобразования<rhs>в один из ограниченных типов. Кроме того, в случае недостаточной памяти, может потерпеть неудачу с<std::bad_alloc>почему?.
    5. <
      template<typenameT>variant&operator=(T&&rhs);
      >

      Требуется:

      • С++11 совместимый компилятор.
      • <rhs>— это величина. В противном случае будет использован предыдущий оператор.
      • <T>должен быть однозначно конвертируемым в один из ограниченных типов (т.е.<T1>,<T2>и т.д.).
      • Каждый ограниченный тип должен соответствовать требованиям концепции MoveAssignable.

      Эффекты:

      		 Если<*this>содержит<T>, то переместить присваивает<rhs>в содержание<*this>. В противном случае содержание<*this>является наилучшим преобразованием<rhs>в один из ограниченных типов, что определяется стандартными правилами разрешения перегрузки, разрушающими предыдущее содержание<*this>(конверсия обычно осуществляется с помощью конструкции перемещения).

      Броски:

      		 Если<*this>содержит<T>, то может не сработать с любыми исключениями, вытекающими из назначения перемещения<rhs>в содержание<*this>. В противном случае может произойти сбой с любыми исключениями, вытекающими из преобразования<rhs>в один из ограниченных типов. Кроме того, в случае недостаточной памяти, может потерпеть неудачу с<std::bad_alloc>почему?.

    variant queries

    1. <
      intwhich()const;
      >

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

      		Нулевой индекс в набор ограниченных типов содержащегося типа<*this>. (Например, если вызвать<variant<int, std::string>>объект, содержащий<std::string>,<which()>вернулся бы<1>.)

      Броски:

      Броски:

      		 Will not throw.
      [ORIG_END] -->
    2. <
      boolempty()const;
      >

      Возврат:

      		<false>:<variant>всегда содержит точно один из своих ограниченных типов. (См.раздел под названием “ «Гарантия никогда не пустует»”для получения дополнительной информации.)

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

      		Облегчает общую совместимость сповышением:: любой.

      Броски:

      Броски:

      Броски:

      		 Will not throw.
      [ORIG_END] -->
    3. <
      conststd::type_info&type()const;
      >

      Примечания:

      		<boost::variant>usues Boost. Библиотека TypeIndex возвращается<const boost::typeindex::type_info &>. Этот метод доступен даже при отключении RTTI.

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

      		<typeid(x)>, где<x>является содержанием<*this>.

      Бросает:

      Броски:

      		 Will not throw.
      [ORIG_END] -->

    variant relational

    1. <
      booloperator==(constvariant&rhs)const;
template<typenameU>voidoperator==(constU&)const;
      >Сравнение равенства.

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

      Примечания:

      		Возврат перегрузки<void>существует только для того, чтобы запретить неявное преобразование правой стороны оператора в<variant>; таким образом, его использование (целенаправленно) приведет к ошибке времени компиляции.

      Требуется:

      		Каждый ограниченный тип<variant>должен соответствовать требованиям концепции Равенства.
      <true>, если<which() == rhs.which()>и<content_this == content_rhs>, где<content_this>является содержанием<*this>и<content_rhs>является содержанием<rhs>.
      Бросок:

      Бросок:

      Броски:

      		 If which() == rhs.which() then may fail with any exceptions arising from operator==(T,T), where T is the contained type of *this.
      [ORIG_END] -->
    2. <
      booloperator!=(constvariant&rhs)const;
template<typenameU>voidoperator!=(constU&)const;
      >Сравнение неравенства.

      Примечания:

      		Возвращение перегрузки<void>существует только для того, чтобы запретить неявное преобразование правой стороны оператора в<variant>; таким образом, ее использование (целенаправленно) приведет к ошибке компиляции времени.

      Требования:

      		Каждый ограниченный тип<variant>должен соответствовать требованиям концепции Равенства.

      Возврат:

      		<true>, если<!(*this == rhs)>.

      Бросок:

      Броски:

      		 If which() == rhs.which() then may fail with any exceptions arising from operator==(T,T), where T is the contained type of *this.
      [ORIG_END] -->
    3. boolоператор>варианттиповое имяконст>конст>конст>конст>конст>конст>конст>конст>конст>конст>конст>конст>конст>конст>конст>конст>конст>конст< В противном случае:  which() < rhs. which().   
      Броски:
      Броски:
      
If which() == rhs.which() then may fail with
              any exceptions arising from operator<(T,T),
              where T is the contained type of
              *this.
    [ORIG_END] -->
  • <
    booloperator>(constvariant&rhs)const;
template<typenameU>voidoperator>(constU&)const;
    >Больше

    Примечания:

    		Возвращение перегрузки<void>существует только для того, чтобы запретить неявное преобразование правой стороны оператора в<variant>; таким образом, его использование (целенаправленно) приведет к ошибке компиляции времени.

    Требуется:

    		Каждый ограниченный тип<variant>должен соответствовать требованиям концепции LessThanComparable.

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

    		истинно, если<rhs < *this>.

    Бросок:Бросок:

    Броски:

    		 May fail with any exceptions arising from operator<(T,T), where T is the contained type of *this.
    [ORIG_END] -->
  • <
    booloperator<=(constvariant&rhs)const;
template<typenameU>voidoperator<=(constU&)const;
    >Меньше хан или равное сравнение.

    Примечания:

    		Возврат перегрузки<void>существует только для того, чтобы запретить неявное преобразование правой стороны оператора в<variant>; таким образом, его использование (целенаправленно) приведет к ошибке времени компиляции.

    Требуется:

    		Каждый ограниченный тип<variant>должен соответствовать требованиям концепции LessThanComparable.

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

    		истинно, если<!(*this > rhs)>.

    Бросок:

    Броски:

    		 May fail with any exceptions arising from operator<(T,T), where T is the contained type of *this.
    [ORIG_END] -->
  • <
    booloperator>=(constvariant&rhs)const;
template<typenameU>voidoperator>=(constU&)const;
    >Больше

    Примечания:

    		Возвращение перегрузки<void>существует только для того, чтобы запретить неявное преобразование правой стороны оператора в<variant>; таким образом, ее использование (целенаправленно) приведет к ошибке компиляции времени.

    Требуется:

    		Каждый ограниченный тип<variant>должен соответствовать требованиям концепции LessThanComparable.

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

    		истинно, если<!(*this < lhs)>.

    Бросок: [889_BEGIN]

    Бросок:

    Броски:

    		 May fail with any exceptions arising from operator<(T,T), where T is the contained type of *this.
    [ORIG_END] -->
    • Copyright © 2002, 2003 Eric Friedman, Itay Maman

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

    Статья Class template variant раздела 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 22:36:15/0.013790130615234/0