注意:我知道boost::variant，但我对设计原则很好奇。这个问题主要是为了自学。

原帖

在我目前的工作中，我发现了一个旧的变体类实现。它是用 union 实现的，并且只能支持少数几种数据类型。我一直在思考应该如何设计一个改进的版本。经过一番修补后，我最终得到了一些似乎可行的东西。不过我想知道你对此的看法。这里是:

#include <iostream>
#include <map>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <boost/shared_ptr.hpp>

class Variant
{
public:
    Variant() { }

    template<class T>
    Variant(T inValue) :
        mImpl(new VariantImpl<T>(inValue)),
        mClassName(typeid(T).name())
    {
    }

    template<class T>
    T getValue() const
    {
        if (typeid(T).name() != mClassName)
        {
            throw std::logic_error("Non-matching types!");
        }

        return dynamic_cast<VariantImpl<T>*>(mImpl.get())->getValue();
    }

    template<class T>
    void setValue(T inValue)
    {
        mImpl.reset(new VariantImpl<T>(inValue));
        mClassName = typeid(T).name();
    }

private:
    struct AbstractVariantImpl
    {
        virtual ~AbstractVariantImpl() {}
    };

    template<class T>
    struct VariantImpl : public AbstractVariantImpl
    {
        VariantImpl(T inValue) : mValue(inValue) { }

        ~VariantImpl() {}

        T getValue() const { return mValue; }

        T mValue;
    };

    boost::shared_ptr<AbstractVariantImpl> mImpl;
    std::string mClassName;
};

int main()
{
    // Store int
    Variant v(10);
    int a = 0;
    a = v.getValue<int>();
    std::cout << "a = " << a << std::endl;

    // Store float
    v.setValue<float>(12.34);
    float d = v.getValue<float>();
    std::cout << "d = " << d << std::endl;

    // Store map<string, string>
    typedef std::map<std::string, std::string> Mapping;
    Mapping m;
    m["one"] = "uno";
    m["two"] = "due";
    m["three"] = "tre";
    v.setValue<Mapping>(m);
    Mapping m2 = v.getValue<Mapping>();
    std::cout << "m2[\"one\"] = " << m2["one"] << std::endl;
    return 0;
}

输出正确:

a = 10
d = 12.34
m2["one"] = uno

我的 SO 问题是:

• 这个实现是否正确？
• getValue() 中的动态转换是否会按预期工作(我不确定)
• 我应该将 T 作为 const 引用返回吗？或者我可以依靠返回值优化来发挥作用吗？
• 还有其他问题或建议吗？

更新

感谢@templatetypedef 的建议。此更新版本仅使用 dynamic_cast 来检查类型是否匹配。由于 TypeWrapper 类(我从 Poco C++ 项目中无耻地窃取了它)，现在避免了由 constness 差异引起的类型不匹配。

所以这是当前版本。但它可能包含一些错误，因为我不熟悉在模板模板上修改 const/ref 的想法。明天我会焕然一新。

template <typename T>
struct TypeWrapper
{
    typedef T TYPE;
    typedef const T CONSTTYPE;
    typedef T& REFTYPE;
    typedef const T& CONSTREFTYPE;
};

template <typename T>
struct TypeWrapper<const T>
{
    typedef T TYPE;
    typedef const T CONSTTYPE;
    typedef T& REFTYPE;
    typedef const T& CONSTREFTYPE;
};

template <typename T>
struct TypeWrapper<const T&>
{
    typedef T TYPE;
    typedef const T CONSTTYPE;
    typedef T& REFTYPE;
    typedef const T& CONSTREFTYPE;
};

template <typename T>
struct TypeWrapper<T&>
{
    typedef T TYPE;
    typedef const T CONSTTYPE;
    typedef T& REFTYPE;
    typedef const T& CONSTREFTYPE;
};

class Variant
{
public:
    Variant() { }

    template<class T>
    Variant(T inValue) :
        mImpl(new VariantImpl<typename TypeWrapper<T>::TYPE>(inValue))
    {
    }

    template<class T>
    typename TypeWrapper<T>::REFTYPE getValue()
    {
        return dynamic_cast<VariantImpl<typename TypeWrapper<T>::TYPE>&>(*mImpl.get()).mValue;
    }

    template<class T>
    typename TypeWrapper<T>::CONSTREFTYPE getValue() const
    {
        return dynamic_cast<VariantImpl<typename TypeWrapper<T>::TYPE>&>(*mImpl.get()).mValue;
    }

    template<class T>
    void setValue(typename TypeWrapper<T>::CONSTREFTYPE inValue)
    {
        mImpl.reset(new VariantImpl<typename TypeWrapper<T>::TYPE>(inValue));
    }

private:
    struct AbstractVariantImpl
    {
        virtual ~AbstractVariantImpl() {}
    };

    template<class T>
    struct VariantImpl : public AbstractVariantImpl
    {
        VariantImpl(T inValue) : mValue(inValue) { }

        ~VariantImpl() {}

        T mValue;
    };

    boost::shared_ptr<AbstractVariantImpl> mImpl;
};

最佳答案

这个实现接近正确，但看起来它有一些错误。例如这段代码:

if (typeid(T).name() != mClassName)

不能保证正常工作，因为 type_info 中的 .name() 函数不能保证为每种类型返回唯一值。如果你想检查类型是否匹配，你可能应该使用这样的东西:

if (typeid(*mImpl) == typeid(VariantImpl<T>))

更准确地检查类型是否匹配。当然，您需要注意 const 问题，因为存储 const T 和存储 T 会产生不同的类型。

至于您关于 dynamic_cast 的问题，在您所描述的情况下，您不需要使用 dynamic_cast，因为您已经进行了检查以确认类型将匹配。相反，您可以只使用 static_cast，因为您已经发现了类型错误的情况。

不过，更重要的是，您在此处定义的是一个“不受限制的变体”，它绝对可以容纳任何东西，而不仅仅是一小部分受限制的类型(您通常会在变体中找到)。虽然我真的很喜欢这段代码，但我还是建议改用 Boost.Any 或 Boost.Variant 之类的东西，它们已经过广泛的调试和测试。话虽如此，恭喜您找到了成功的关键技巧!

关于c++ - 实现一个 "variant"类，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/5319216/