14

std::无序集是否有插入迭代器？据我所知，std::inserter需要一个迭代器参数。这对于无序容器（至少对于boost::unordered_set）是不安全的，因为它们可能在insert操作期间重新分配并使传递的.begin()迭代器无效。

所以目前我必须传递我自己的迭代器，它本质上是一个boost::function_output_iterator带有简单调用unorderedSet.insert(param1).

为什么它std::inserter甚至需要迭代器hint参数？

4

1 回答 1

3

没有。hint需要参数的原因是它std::inserter适用于在插入上下文中需要位置的容器。如您所知，无序容器并非如此。

vector在一个容器的例子中，知道position是插入的要求。从cppreference：

(1)
iterator insert( iterator pos, const T& value ); // (until C++11)
iterator insert( const_iterator pos, const T& value ); // (since C++11)

 (2)
iterator insert( const_iterator pos, T&& value ); // (since C++11)

(3)     
void insert( iterator pos, size_type count, const T& value ); // (until C++11)
iterator insert( const_iterator pos, size_type count, const T& value ); // (since C++11)

(4)     
template< class InputIt >
void insert( iterator pos, InputIt first, InputIt last); // (until C++11)
template< class InputIt >
iterator insert( const_iterator pos, InputIt first, InputIt last ); // (since C++11)

(5)
iterator insert( const_iterator pos, std::initializer_list<T> ilist ); // (since C++11)

在容器中的指定位置插入元素。

  1-2)在 pos 之前
插入值   3) 在 pos 之前插入值的计数副本4)在 pos 之前插入
  范围 [first, last) 中的元素。        如果 InputIt 是整数类型，则此重载与重载 (3) 具有相同的效果。 （直到 C++11）        此重载仅在 InputIt 符合 LegacyInputIterator 条件时参与重载决议，以避免与重载 (3) 产生歧义。 (C++11 起) 如果 first 和 last 是 *this 的迭代器，则行为未定义。5)在 pos 之前   插入初始化列表 ilist 中的元素。


我知道这不是您正在寻找的答案，但是推出自己的答案很容易，即使不是有点冗长：

template<typename Container>
class unordered_inserter {
public:
    using iterator_category = std::output_iterator_tag;
    using value_type = void;
    using reference_type = void;
    using difference_type = void;
    using pointer = void;
    using reference = void;
    using container_type = Container;

    unordered_inserter& operator++() {return *this;} //no-op
    unordered_inserter& operator++(int) {return *this;} //no-op
    unordered_inserter& operator*() {return *this;} //no-op
    constexpr unordered_inserter& operator=(const typename Container::value_type& value) {
        container->insert(value);
        return *this;
    }
    constexpr unordered_inserter& operator=(typename Container::value_type&& value) {
        container->insert(std::move(value));
        return *this;
    }
    unordered_inserter(Container* container)
        :    container(container)
    {}
protected:
    Container* container;
};

这可能可以重构以支持其他类型的插入，但我认为这已经足够了。

这是我玩的一点：

int main() {
    std::unordered_map<int, int> m;
    std::istringstream iss("1 2 3 4 5 6");

    std::transform(std::istream_iterator<int>(iss), std::istream_iterator<int>(), unordered_inserter(&m), [](int v) {
        return decltype(m)::value_type{v, v*v};
    });
    std::transform(m.begin(), m.end(), std::ostream_iterator<std::string>(std::cout, "\n"), [](auto pair) {
        return std::to_string(pair.first) + "," + std::to_string(pair.second);
    });
}

住在神螺栓上

这里要注意的一点是，您断言将此hint参数传递给无序容器是不安全的是错误的。当operator=被调用并且一个新元素被插入到容器中时，该iter成员被更新为任何insert返回值。由于这个值必须是有效的，所以iter永远不可能无效。

于 2020-01-10T23:17:22.483 回答