微型模板库：variant

variant 的伪代码如下：

template < typename T1, typename T2, ... > 
struct variant
{
    //list of user types
    typedef meta::typelist< T1, T2,...> types;
    
    //initialization 
    variant() : p_(0) {}
    
    template< typename T >
    variant( const T& d ) : p_(0) 
    {
        //find the index of this type in the variant typelist
        which_ = find_type<T>::value;
        //in place construction
        p_ = new(buffer_) data_holder<T>(d);
    }
    
    virtual ~variant() { destroy(); }
    
    inline int which() const { return which_; }
    
    inline bool is_valid() const { return p_ != 0; }
    
    void destroy() 
    { 
        if(!is_valid()) return;
        p_->~data_holder_base(); 
        p_ = 0;
    }
    
private:
    
    //data_holder is a wrapper for the user types
    
    struct data_holder_base 
    { 
        virtual ~data_holder_base() {}
    };
    
    temlate< typename T >
    struct data_holder : data_holder_base
    {
        T d_;
        data_holder( const T& d ) : d_(d) {}
    };
    
    //list of data holder types
    typedef meta::typelist<data_holder<T1>, data_holder<T2>,...> holder_types;
    
    //reserve enough space to hold the largest type
    char buffer_[find_largest_type<holder_types>::value];


    
    //pointer to the controlled object
    data_holder_base *p_;
    
    //object type index
    int which_;
};

使用 variant

typedef variant<int, double> my_variant;

void f( my_variant& v )
{
    int n;
    double x;
    switch( v.which() )
    {
    case 0:  //int variable
        n = get<int>(v);
        //do something with int;
        break;
        
    case 1:  //double variable
        x = get<double>(v);
        //do something with the double;
        break;
    }
};

正如您所见，get<> 函数可用于从 variant<> 中检索类型化数据。显然，这个 switch 语句很丑陋且不太灵活。函数 f() 必须知道 my_variant 中的类型索引。解决这些问题的一种方法是利用 Gof 访问者模式的思想。

typedef variant<int, double> my_variant;

struct visitor
{
    void operator()(int n)
    {
    //do something with the int;
    ...
    }
    void operator()(double x)
    {
    //do something with the double;
    ...
    }
    
    //ignore any other types
    template< typename T >
    void operator()( T d )
    {
    }
};

my_variant var;
visitor vis;
apply_visitor(var, vis);

我认为这样看起来好多了，我们不必担心类型索引或任何其他类型的标识符。apply_visitor() 函数实现在TTL中。apply_visitor 执行以下操作：

variant 的另一个有趣实现是事件分发。假设我们有一个事件源，可以生成多种事件类型。为了简单起见，事件类型是 int 和 double。我们可以这样定义事件类型：

typedef variant< int, double > event;

typedef function< void (event&) > callback;

typedef variant< int, double > event;
typedef function< void (event&) > callback;

struct event_source
{
    callback cb_

    event_source( callback& cb ) : cb_(cb) {}

    void do_something()
    {
        event ev;

        ...
        //generate int event
        ev = 1;
        cb_( ev );

        ....
        //generate double event
        ev = 2.3;
        cb_( ev );
    }
};

//define our event vistor
struct event_visitor
{
    //process int event
    void operator()(int n)
    { 
        cout << "got int:" << n;
    }
    
    //process double event
    void operator()(double n)
    { 
        cout << "got double:" << n;
    }
    
    //ignore any other events
    template< typename T >
    void operator()( T d )
    {
    }
}

void my_callback( event& e )
{
    event_visitor vistor;
    apply_visitor(e, vistor);
}

main()
{
    event_source src(my_callback);
    src.do_something();
}