0

我正在使用一个相当笨拙的 c 接口来存储集合。该类LowLevelStorer代表我为此接口编写的包装器。该类Storer是与自身相关的高级类Data。它会缓存数据并将数据捆绑成更复杂的数据类型，只有LowLevelStorer. 我的其余代码仅使用Data并且不了解LowLevelData.

在下面的示例代码中，我希望变体中的成员Data包含在LowLevelData变体中。有没有办法指定我是如何做到的？

我真的不明白为什么下面的代码可以编译，以及为什么它实际上可以正常工作。也就是说，void operator()(const SimplePath&, const Data& data) const需要一个 Data 引用，但似乎在调用时正确地将其转换为 LowLevelData 对象void operator()(const LowLevelData& data) const。怎么会这样？

关于我的数据对象，这里是否有很多副本发生在幕后？

#include "boost/variant.hpp"
#include "boost/variant/apply_visitor.hpp"
#include <vector>

class Complex{};
typedef boost::variant< std::vector<Complex>, std::vector<int>, std::vector<std::string> > LowLevelData;

class LowLevelStorer
{
public:
    LowLevelStorer(): _storeVisitor(StoreVisitor()){}

    void operator()(const LowLevelData& data) const 
    {
        boost::apply_visitor(_storeVisitor, data);
    }

private:
    class StoreVisitor: public boost::static_visitor<>
    {
    public:
        void operator()(const std::vector<Complex>&) const {}

        void operator()(const std::vector<int>& i) const {}

        void operator()(const std::vector<std::string>&) const {}
    };

    StoreVisitor _storeVisitor;
};


struct SimplePath{};
struct BundlePath{};
typedef boost::variant< SimplePath, BundlePath > Path;

typedef boost::variant< std::vector<std::string>, std::vector<int> > Data;

class Storer
{
public:
    Storer(const LowLevelStorer& lowLevelStorer): _converter(Converter(lowLevelStorer)){}

    void operator()(const Path& path, const Data& data) const 
    {
        boost::apply_visitor(_converter, path, data);
    }

private:
    class Converter: public boost::static_visitor<>
    {
    public:
        Converter(const LowLevelStorer& lowLevelStorer): _lowLevelStorer(lowLevelStorer){}

        void operator()(const SimplePath&, const Data& data) const {
            _lowLevelStorer(data);
        }

        void operator()(const BundlePath&, const Data& data) const {
            _lowLevelStorer(std::vector<Complex>());
        }
    private:
        const LowLevelStorer _lowLevelStorer;
    };

    const Converter _converter;
};

int main()
{
    Storer storer((LowLevelStorer()));
    std::vector<int> v;
    v.push_back(13);
    storer(Path(SimplePath()),v);

    return 0;
}
4

1 回答 1

2

当您将参数提供为另一个变量时，我怀疑它采用一个变量的原因是因为您的两个变量都具有共同的所有类型，这使得您的变量可以相互转换。

我认为只使用所有三种类型的一种变体并完全跳过另一种是完全可以的，因为第二种只是第一种类型的子集。

于 2013-03-11T09:52:22.390 回答