Variant

Header: "boost/variant.hpp"

This contains all of the Variant library through a single header file.

 "boost/variant/variant_fwd.hpp" 

contains forward declarations of the variant class templates.

 "boost/variant/variant.hpp" 

contains the definitions for the variant class templates.

 "boost/variant/apply_visitor.hpp" 

contains the functionality for applying visitors to variants.

 "boost/variant/get.hpp" 

contains the template function get.

 "boost/variant/bad_visit.hpp" 

contains the definition for the exception class bad_visit.

 "boost/variant/static_visitor.hpp" 

contains the definition for the visitor class template.

The following partial synopsis covers the most important members of the variant class template. Other functionality, such as the visitation mechanism, direct typesafe value retrieval, and advanced features such as creating the set of types through type sequences, are described in the "Usage" section.

 namespace boost {   template <typename T1,typename T2=unspecified, ...,     typename TN=unspecified>   class variant {   public:     variant();          variant(const variant& other);          template <typename T> variant(const T& operand);                template <typename U1, typename U2, ..., typename UN>       variant(const variant<U1, U2, ..., UN>& operand);          ~variant();     template <typename T> variant& operator=(const T& rhs);     int which() const;     bool empty() const;     const std::type_info& type() const;     bool operator==(const variant& rhs) const;     bool operator<(const variant& rhs) const;   }; } 

Members

 variant(); 

This constructor default constructs the first type of the set of types for the variant. This means that the first type used when declaring the variant type must be default constructible, or else the variant type itself cannot be default constructed. This constructor propagates any exceptions thrown from the first type's constructor.

 variant(const variant& other); 

The copy constructor copies the current value of other, propagating any exceptions thrown from other's current type's copy constructor.

 template <typename T> variant(const T& operand); 

This constructor creates a new variant from operand. The operand, of type T, must be unambiguously convertible to one of the set of bound types. Exceptions thrown when copying or converting the operand are propagated.

 template <typename U1,typename U2,...,typename UN>   variant(const variant<U1,U2,...,UN>& operand); 

This constructor allows construction from another variant type, where for each of the types U1, U2…UN, there exists an unambiguous conversion to T1,T2…TN (the set of types of the variant being constructed). Exceptions thrown when copying or converting the operand are propagated.

 ~variant(); 

Destroys the variant, and calls the destructor for the active value. Note that for pointer types, the destructor is not called (destroying the pointer is a no-op). This destructor never throws.

 template <typename T> variant& operator=(const T& rhs); 

This operator discards the current value and assigns the value rhs. The type T must be unambiguously convertible to one of the bound types in the variant. If T is the type of the current value in the variant, rhs is copy assigned to the current value; any exceptions thrown by T's copy assignment operator, if any, will propagate. If the variant's current value's type is not T, the current value is replaced by one created by the (copy) constructor of the type, corresponding to T, selected from the set of bound types. Any exceptions thrown by that constructor will propagate. This function may also throw bad_alloc.

 int which() const; 

Returns the zero-based index, in the set of bounded types, of the current value's type. This function never throws.

 bool empty() const; 

This function always returns false, because a variant is never empty. This function exists to allow generic code to treat variants and boost::anys uniformly. This function never throws.

 const std::type_info& type() const; 

Returns the type_info for the current value. This function never throws.

 bool operator==(const variant& rhs) const; 

Returns true if *this and rhs are equal, which means that which()==rhs.which() and the current value of *this and rhs are equal according to the equality operator of the current value's type. This necessitates that all of the bounded types be EqualityComparable. Any exceptions thrown by operator== of the current value's type are propagated.

 bool operator<(const variant& rhs) const; 

The less than comparison returns which()<rhs.which() or if the indices are equal, it returns the result of calling operator< on the current value of *this and rhs. Any exceptions thrown by operator< of the current value's type are propagated.