Question

我有一个容器变体如下：

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

我从ValueContainer对象（C结构）填充Container对象，如下所示：

class ContainerAppender: public boost::static_visitor<>
{
public:
    void setValueToAppend(const Value* value){
        _value = value;
    }

    void operator()(std::vector<int>& container) const {
        container.push_back(_value->value.i);
    }

    void operator()(std::vector<std::string>& container) const {
        container.push_back(_value->value.s);
    }

    ...

private:
    const Value* _value;
};

void fillContainer(Container& container, ValueContainer* cContainer) {
    if(cContainer) {
        ContainerAppender append;
        for(int i = 0; i < cContainer->nunberOfValues; i++) {
            append.setValueToAppend(&cContainer->values[i]);
            boost::apply_visitor(append, container);
        }
    }
}

我无法自由改变C结构。

我不喜欢我填充容器的解决方案，因为我正在访问每个循环，尽管容器类型永远不会更改。感觉有更好的方法。你能帮忙吗？

这是C联盟：

typedef struct Value {
    union {
        int   i;
        const char* s;
    } value;
} Value_T;

typedef struct ValueContainer {
    Type type;
    unsigned int numberOfValues;
    Value *values;
} ValueContainer_T;

Answer 1

访客真的有必要吗？考虑一下：

template<typename T>
T value_get(Value_T const &c_variant) {
    return T();
}

template<>
int value_get<int>(Value_T const &c_variant) {
    return c_variant.i;
}

template<>
const char* value_get<const char*>(Value_T const &c_variant) {
    return c_variant.s;
}

template<typename T> 
std::vector<T> fill_vector(ValueContainer_T const& c_container) {
    std::vector<T> cpp_container(c_container.numberOfValues);
    for(size_t i = 0; i < c_container.numberOfValues; ++i)
        cpp_container[i] = value_get<T>(c_container.values[i]);
    return cpp_container;
}

对我来说更简单。

将值附加到容器的变体

1 个答案: