0

我有一个容器变体如下：

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;
4

1 回答 1

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

对我来说看起来更简单。

于 2013-05-24T09:07:50.003 回答