Reference

參考

概念

BoundedType
StaticVisitor
OutputStreamable

BoundedType

有關 有界類型 的要求如下：

可複製構造 [20.1.3]。
析構函數支持無拋出的異常安全保證。
在 variant 模板實例化處，類型是完整的。(關於如何用類型包裝器接受不完整類型以實現遞歸 variant 類型，請見 boost::recursive_wrapper<T>)。

被指定作為 variant 的模板參數的類型必須至少滿足以上要求。此外，只有在其有界類型滿足以下額外要求時，variant 的某些特性才可用：

可賦值：variant 本身為 可賦值的 當且僅當它的每一個有界類型都滿足該概念的要求。(注意，最外層的 const-限定類型以及引用類型不能滿足這些要求)
可缺省構造 [20.1.4]：variant 本身是可缺省構造的當且僅當它的第一個有界類型(即 T1)滿足該概念的要求。
相等性可比較：variant 本身是相等性可比較的當且僅當它的每一個有界類型都滿足該概念的要求。
小於關係可比較：variant 本身是小於關係可比較的當且僅當它的每一個有界類型都滿足該概念的要求。
可流輸出：variant 本身是 可流輸出的 當且僅當它的每一個有界類型都滿足該概念的要求。

StaticVisitor

例子

對於類型 T 的 靜態訪問者 的要求如下：

必須通過重載 operator() 以支持象函數那樣的調用，明確接受類型為 T 的任意值。
必須提供內嵌類型 result_type. (有關如何將函數作為訪問者使用，請見 boost::visitor_ptr)
如果 result_type 不是 void, 則該函數對象的每個操作必須返回一個可以隱式轉換為 result_type 的值。

例子

以下類滿足作為多個類型的靜態訪問者的要求(如，顯式的：int 和 std::string; 或者隱式的：short 和 const char *; 等等)：

class my_visitor
    : public boost::static_visitor<int>
{
public:

    int operator()(int i)
    {
        return i * 2;
    }

    int operator()(const std::string& s)
    {
        return s.length();
    }

};

以下是另一個例子，它的函數調用操作符是一個模板成員函數，可以操作多種類型的值。因此，以下類可作為任意支持流輸出的類型的訪問者(如 int, double, std::string, 等等)：

class printer
    : public boost::static_visitor<>
{
    template <typename T>
    void operator()(const T& t)
    {
        std::cout << t << std::endl;
    }
};

OutputStreamable

對 可流輸出 類型 T 的要求如下：

對於類型 T 的任意對像 t, std::cout << t 必須是有效表達式。

頭文件 <boost/variant.hpp>

該頭文件只是為了方便用戶使用而存在，它包含了 boost/variant 目錄中的所有頭文件。

頭文件 <boost/variant/variant_fwd.hpp>

提供 boost::variant, boost::make_variant_over, boost::make_recursive_variant, 和 boost::make_recursive_variant_over 類模板的前向聲明以及 boost::recursive_variant_ tag 類型。還定義了以下幾個預處理器符號：

BOOST_VARIANT_LIMIT_TYPES
BOOST_VARIANT_ENUM_PARAMS(param)
BOOST_VARIANT_ENUM_SHIFTED_PARAMS(param)
BOOST_VARIANT_NO_REFERENCE_SUPPORT
BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT
BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT

頭文件 <boost/variant/variant.hpp>

namespace boost {
  template<typename T1, typename T2 = unspecified, ..., 
           typename TN = unspecified> 
    class variant;

  template<typename Sequence> class make_variant_over;
  template<typename T1, typename T2, ..., typename TN> 
    void swap(variant<T1, T2, ..., TN> &, variant<T1, T2, ..., TN> &);
  template<typename ElemType, typename Traits, typename T1, typename T2, ..., 
           typename TN> 
    std::basic_ostream<ElemType,Traits> & 
    operator<<(std::basic_ostream<ElemType,Traits> &, 
               const variant<T1, T2, ..., TN> &);
}

頭文件 <boost/variant/recursive_variant.hpp>

namespace boost {
  typedef unspecified recursive_variant_;

  template<typename T1, typename T2 = unspecified, ..., 
           typename TN = unspecified> 
    class make_recursive_variant;
  template<typename Sequence> class make_recursive_variant_over;
}

頭文件 <boost/variant/recursive_wrapper.hpp>

namespace boost {
  template<typename T> class recursive_wrapper;
  template<typename T> class is_recursive_wrapper;
  template<typename T> class unwrap_recursive_wrapper;
}

頭文件 <boost/variant/apply_visitor.hpp>

namespace boost {
  template<typename Visitor> class apply_visitor_delayed_t;
  template<typename Visitor, typename Variant> 
    typename Visitor::result_type apply_visitor(Visitor &, Variant &);
  template<typename Visitor, typename Variant> 
    typename Visitor::result_type apply_visitor(const Visitor &, Variant &);
  template<typename BinaryVisitor, typename Variant1, typename Variant2> 
    typename BinaryVisitor::result_type 
    apply_visitor(BinaryVisitor &, Variant1 &, Variant2 &);
  template<typename BinaryVisitor, typename Variant1, typename Variant2> 
    typename BinaryVisitor::result_type 
    apply_visitor(const BinaryVisitor &, Variant1 &, Variant2 &);
  template<typename Visitor> 
    apply_visitor_delayed_t<Visitor> apply_visitor(Visitor &);
}

頭文件 <boost/variant/get.hpp>

namespace boost {
  class bad_get;
  template<typename U, typename T1, typename T2, ..., typename TN> 
    U * get(variant<T1, T2, ..., TN> *);
  template<typename U, typename T1, typename T2, ..., typename TN> 
    const U * get(const variant<T1, T2, ..., TN> *);
  template<typename U, typename T1, typename T2, ..., typename TN> 
    U & get(variant<T1, T2, ..., TN> &);
  template<typename U, typename T1, typename T2, ..., typename TN> 
    const U & get(const variant<T1, T2, ..., TN> &);
}

頭文件 <boost/variant/bad_visit.hpp>

namespace boost {
  class bad_visit;
}

頭文件 <boost/variant/static_visitor.hpp>

namespace boost {
  template<typename ResultType> class static_visitor;
}

頭文件 <boost/variant/visitor_ptr.hpp>

namespace boost {
  template<typename T, typename R> class visitor_ptr_t;
  template<typename R, typename T> visitor_ptr_t<T,R> visitor_ptr(R (*)(T));
}