D语言实现的variant

boost.variant 是安全、范型、基于栈的可识别联合容器，下面的代码是其在D语言中的等价实现。借助D语言强大的元编程能力，其与C++的版本相比，代码清晰，对类型安全有更大的保证。

• boost.variant 文档：http://www.boost.org/doc/html/variant.html

• boost.any 和 boost.variant 的区别与比较： http://www.boost.org/doc/html/variant/misc.html#variant.versus-any

cpp 代码

// Module:  variant.d
// Author:  Oldrev (wstring#AT#gmail.com)
// License: BSD

module variant;

import std.typetuple;
import std.traits;
import std.stdio;

private template MaxSizeImp(T, V...)
{
    static if(V.length > 0)
        private const int tailResult = MaxSizeImp!(V).result;
    else
        private const int tailResult = T.sizeof;

    public const int result = T.sizeof > tailResult ? T.sizeof : tailResult;
};

private template MaxSize(TList...)
{
    const int MaxSize = MaxSizeImp!(TList).result;
}

struct Variant(TList...)
{
    public alias TList TypeList;
    public alias Variant!(TypeList) SelfType;
    private alias ubyte[MaxSize!(TypeList)] Holder;

    private Holder  m_held;
    private int     m_which = -1;

    public int which()
    {
        return m_which;
    }

    public SelfType assign(ValueType)(ValueType val)
    {
        static if(is(ValueType == SelfType))
        {
            m_held[] = val.m_held[];
            m_which = which;
        }
        else
        {
            const int i = IndexOf!(ValueType, TypeList);
            static assert(i >= 0);
            ValueType* heldPtr = cast(ValueType*)m_held.ptr;
            *heldPtr = val;
            m_which = i;
        }

        return *this;
    }

    public SelfType opAssign(ValueType)(ValueType rhs)
    {
        return assign!(ValueType)(rhs);
    }

    public bool opEquals(ValueType)(ValueType rhs)
    {
        assert(!empty);

        static if(is(ValueType == SelfType))
        {
            foreach(T; TypeList)
            {
                const int i = IndexOf!(T, TypeList);
                if(i == which)
                {
                    return (rhs.which == which) && (get!(T) == rhs.get!(T));
                }
            }
        }
        else
        {
            const int i = IndexOf!(ValueType, TypeList);
            static assert(i >= 0);

            return get!(ValueType)() == rhs;
        }
    }

    public int opCmp(ValueType)(ValueType rhs)
    {
        if(rhs == *this)return 0;
        static if(is(ValueType == SelfType))
        {
            foreach(T; TypeList)
            {
                const int i = IndexOf!(T, TypeList);
                if((i == which) && (rhs.which == which))
                {
                    return get!(T) < rhs.get!(T) ? -1 : 1;
                }
            }
        }
        else
        {
            const int i = IndexOf!(ValueType, TypeList);
            static assert(i >= 0);

            return get!(ValueType)() < rhs ? -1 : 1;
        }
    }

    public TypeInfo type()
    {
        foreach(T; TypeList)
        {
            const int i = IndexOf!(T, TypeList);
            if(i == which)
            {
                return typeid(TypeList[i]);
            }
        }
    }

    public ValueType get(ValueType)()
    {
        assert(typeid(ValueType) == type);
        return *(cast(ValueType*)m_held.ptr);
    }

    public bool empty()
    {
        return m_which < 0;
    }

    public void swap(inout SelfType var)
    {
        Holder h;
        h[] = m_held;
        int w = which;
        m_held[] = var.m_held;
        m_which = var.which;
        var.m_held[] = h;
        var.m_which = w;
    }

    public static SelfType opCall(ValueType)(ValueType val)
    {
        SelfType var;
        var = val;
        return var;
    }

}

void main()
{
    class Foo
    {
        public:
        int n = 0;
        int x = 0;
        int y = 0;
        int z = 0;

        Foo opAssign(int rhs)
        {
            x = rhs;
            y = rhs;
            z = rhs;
            return this;
        }
    }

    struct Bar
    {
        public:
        int x = 0;
        int y = 1;
        int z = 2;
    }

    Variant!(double, int, char[], Foo, Bar) v = 2; // DMD 0.177 new feature
    assert(v == 2);
    assert(v <= 2);
    v = 2.22;
    assert(v == 2.22);
    assert(v.type == typeid(double));
    v = new Foo;
    assert(v.type == typeid(Foo));
    v.get!(Foo)() = 2;
    assert(v.get!(Foo)().z == 2);
    typeof(v) v2 = v;
    assert(v2 == v);
    v = "Foobar".dup;
    assert(v == "Foobar".dup);

    v.swap(v2);
    assert(v2.get!(char[])() == "Foobar");

    Bar b;
    b.x = 10;
    v = b;
    assert(v.get!(Bar)().x == 10);

}

评论

7 楼 oldrev 2007-03-16  

引用

这个实现可以稍稍优化一下，因为ValueType是在编译期可以知道的，所以可以用IndexOf确定它在TList中的位置，直接和which判断就行了，不用再调用type()函数。

我就是知道 assert 可以被屏蔽掉，所以才偷了个懒....

引用

另外断言只在debug环境下有效，如果是不兼容的类型，cast结果会是空指针，这时可能会出现一个段错误了。

对阿，这里应该用异常还是 assert 应该再仔细研究一下。

6 楼 oldrev 2007-03-16  

引用

不过这个opCast只能转到一种类型，可以自己实现多种类型的转换，当然也就用不了cast了：

C++ 的用户自定义类型转换操作符可以实现隐式转换，如：

operator double() const {...}

这个特性虽然方便但也很容易引起难以发现的 bug

5 楼 qiezi 2007-03-16  

     public ValueType get(ValueType)()  
     {  
         assert(typeid(ValueType) == type);  
         return *(cast(ValueType*)m_held.ptr);  
     } 

这个实现可以稍稍优化一下，因为ValueType是在编译期可以知道的，所以可以用IndexOf确定它在TList中的位置，直接和which判断就行了，不用再调用type()函数。

另外断言只在debug环境下有效，如果是不兼容的类型，cast结果会是空指针，这时可能会出现一个段错误了。

4 楼 qiezi 2007-03-16  

不过这个opCast只能转到一种类型，可以自己实现多种类型的转换，当然也就用不了cast了：

import std.stdio;

class Foo{
  int convert(T:int)(){return 3;}
  long convert(T:long)(){return 4;}
}

void main(){
  Foo f = new Foo;
  writefln(f.convert!(int));
  writefln(f.convert!(long));
}

3 楼 qiezi 2007-03-16  

可以呀，opCast就是了。。

http://digitalmars.com/d/operatoroverloading.html

2 楼 oldrev 2007-03-15  

为什么D不能重载类型转换操作符呢

1 楼 ideage 2007-03-07  

这个好东西也可以贡献到Tango了!发布到火星吧!