C++ boost:：variant成员另一个boost:：variant的子集

我正在使用一个相当笨拙的c接口来存储集合。类

LowLevelStorer

表示我为此接口编写的包装器。

Storer

类是一个涉及

数据的高级类。它可以缓存数据，并将数据绑定到只有
低层存储者才知道的更复杂的数据类型中。我的代码的其余部分只使用
数据
，不知道
低层数据

在下面的示例代码中，我希望
Data
变量中的成员包含在
LowLevelData
变量中。有没有办法说明我是如何做到这一点的

我真正不明白的是，为什么下面的代码可以编译，以及为什么它实际上可以正常工作。也就是说，
void operator（）（const-SimplePath&，const-Data&Data）const
接受数据引用，但在调用
void operator（）（const-LowLevelData&Data）const
时似乎正确地将其转换为LowLevelData对象。这怎么可能

关于我的数据对象，是否有很多拷贝在幕后发生

#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;
}

#包括“boost/variant.hpp”
#包括“boost/variant/apply_visitor.hpp”
#包括
类复数{}；
typedef boost:：variableloveldata；
类低层存储器
{
公众：
LowLevelStorer（）：storeVisitor（storeVisitor（））{}
void运算符（）（常量低位数据和数据）常量
{
boost:：apply_visitor（_storeVisitor，data）；
}
私人：
类StoreVisitor:public boost:：static\u visitor
{
公众：
void运算符（）（const std:：vector&）const{}
void运算符（）（const std:：vector&i）const{}
void运算符（）（const std:：vector&）const{}
};
商店访客(StoreVisitor);；
};
结构简单路径{}；
结构BundlePath{}；
typedef boost:：variantPath；
typedef boost:：variant数据；
类存储器
{
公众：
存储器（const LowLevelStorer&LowLevelStorer）：\u转换器（converter（LowLevelStorer））{}
void运算符（）（常量路径和路径，常量数据和数据）常量
{
boost:：apply_visitor（_转换器、路径、数据）；
}
私人：
类转换器：publicboost:：static\u visitor
{
公众：
转换器（const LowLevelStorer和LowLevelStorer）：\u LowLevelStorer（LowLevelStorer）{}
void运算符（）{
_低层存储（数据）；
}
void运算符（）{
_低级存储程序（std:：vector（））；
}
私人：
const lowleverstore_lowleverstore；
};
常量转换器(const Converter)转换器;；
};
int main（）
{
Storer-Storer（（LowLevelStorer（））；
std：：向量v；
v、 推回（13）；
存储器（路径（SimplePath（）），v）；
返回0；
}
当您将参数作为另一个参数提供时，它采用一个变量的原因是，您的两个变量都有相同的类型，这使得您的变量可以相互转换

我认为将一个变量与所有三种类型一起使用，并完全跳过另一个变量是非常好的，因为第二个变量仅仅是第一个类型的子集。
基本上就是这样-一个数据保证包含一个对象，该对象适合低层数据。@Tony the Lion我仍然需要两个变量，因为数据变量不包含std:：vector。此成员由低级接口使用，但我希望它对高级接口隐藏。@Baz那么为什么不与其他两种类型有一个变体，并在需要时将
复杂的
向量作为单独的参数传递？@Tony the Lion，当然感谢您指出明显的原因！