concurrent_unordered_set テンプレート・クラスと concurrent_unordered

概要

挿入および全検索の並列操作をサポートするセットコンテナー用のテンプレート・クラス。

構文

template <typename Key,
             typename Hasher = tbb_hash<Key>,
             typename Equality = std::equal_to<Key>,
             typename Allocator = tbb::tbb_allocator<Key>
class concurrent_unordered_set;

template <typename Key,
             typename Hasher = tbb_hash<Key>,
             typename Equality = std::equal_to<Key>,
             typename Allocator = tbb::tbb_allocator<Key>
class concurrent_unordered_multiset;

ヘッダー

#include "tbb/concurrent_unordered_set.h"

説明

concurrent_unordered_set and concurrent_unordered_multiset support concurrent insertion and traversal, but not concurrent erasure. インターフェイスには使用可能なロックはありません。内部的にロックを保持している可能性はありますが、ユーザー定義コードの呼び出し中にロックが保持されることはありません。次の点を除いて、それぞれ C++11 の std::unordered_set と std::unordered_multiset のセマンティクスと似ています。

C++11 言語機能を必要とする一部のメソッド (rvalue 参照など) は省略されています。
消去メソッドには、並列化セーフでないことを示すプリフィクス unsafe_ が付いています。
バケットメソッドには、挿入操作は並列化セーフでないことを示すプリフィクス unsafe_ が付いています。
concurrent_unordered_set で insert メソッドは、一時的なペアを作成することがあります。これは、別のスレッドが同時に同じキーを挿入した場合は破棄されます。
std::list と同様に、新しいアイテムの挿入はイテレーターを無効にしません。また、すでにマップにあるアイテムの順序を変更することもありません。挿入操作と全検索操作は並列に処理することができます。
iterator イテレーター型および const_iterator イテレーター型は、前方イテレーターです。
挿入操作は、equal_range によって返されたイテレーターを無効にまたは更新しません。そのため、等価でないアイテムが範囲の最後に挿入されることがあります。最初のイテレーターは、挿入操作後も見つかったアイテムを指します。

クラス	重要な違い
`concurrent_unordered_set`	`concurrent_unordered_set` では、アイテムが 1 回だけ挿入される可能性があります。
`concurrent_unordered_multiset`	`concurrent_unordered_multiset` では、アイテムが複数回挿入される可能性があります。 `find` は、検索キーに一致するテーブルの最初のアイテムを返します。ただし、そのアイテムが返される前に、コンテナーへの同時アクセスにより、同じキーの別のアイテムが挿入される可能性があります。

注意

ほかのハッシュテーブルと同様に、等価なキーのハッシュコードは同じでなければなりません。理想的なハッシュ関数は、キーをハッシュコード空間に均等に分散します。

`concurrent_unordered_set` と `concurrent_unordered_multiset` の共通のメンバー

次のコード例で、太字のメソッドは同時に呼び出すことができます。例えば、3 つの異なるスレッドが insert、begin、および size を同時に呼び出すことができます。それぞれの結果は非決定的です。例えば、size の結果は insert 操作の前後では異なります。

public:
    // 型
    typedef Key key_type;
    typedef Key value_type;
    typedef Key mapped_type;
    typedef Hash hasher;
    typedef Equality key_equal;
    typedef Alloc allocator_type;
    typedef typename allocator_type::pointer pointer;
    typedef typename allocator_type::const_pointer const_pointer;
    typedef typename allocator_type::reference reference;
    typedef typename allocator_type::const_reference const_reference;
    typedef implementation-defined size_type;
    typedef implementation-defined difference_type;
    typedef implementation-defined iterator;
    typedef implementation-defined const_iterator;
    typedef implementation-defined local_iterator;
    typedef implementatioｃn-defined const_local_iterator;

    allocator_type get_allocator() const;

    // サイズとキャパシティー
    bool empty() const;     // リニア時間になる!
    size_type size() const; // リニア時間になる!
    size_type max_size() const;

    // イテレーター
    iterator begin();
    const_iterator begin() const;
    iterator end();
    const_iterator end() const;
    const_iterator cbegin() const;
    const_iterator cend() const;

    // 修飾子
    std::pair<iterator, bool> insert(const value_type& x);
    iterator insert(const_iterator hint, const value_type& x);
    template<class InputIterator>
    void insert(InputIterator first,InputIterator last);
    // C++11 仕様
    std::pair<iterator, bool> insert(value_type&& x);
    iterator insert(const_iterator hint, value_type&& x);    
    void insert(std::initializer_list<value_type> il);
    // C++11 仕様
    template<typename... Args>
    std::pair<iterator, bool> emplace(Args&&... args);
    template<typename... Args>
    iterator emplace_hint(const_iterator hint, Args&&... args);


    iterator unsafe_erase(const_iterator position);
    size_type unsafe_erase(const key_type& k);
    iterator unsafe_erase(const_iterator first, const_iterator last);
    void clear();

    // オブザーバー
    hasher hash_function() const;
    key_equal key_eq() const;

    // lookup
    iterator find(const key_type& k);
    const_iterator find(const key_type& k) const;
    size_type count(const key_type& k) const;
    std::pair<iterator, iterator> equal_range(const key_type& k);
    std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;

    // 並列反復
    typedef implementation defined range_type;
    typedef implementation defined const_range_type;
    range_type range();
    const_range_type range() const;

    // バケット・インターフェイス - デバッグ用
    size_type unsafe_bucket_count() const;
    size_type unsafe_max_bucket_count() const;
    size_type unsafe_bucket_size(size_type n);
    size_type unsafe_bucket(const key_type& k) const;
    local_iterator unsafe_begin(size_type n);
    const_local_iterator unsafe_begin(size_type n) const;
    local_iterator unsafe_end(size_type n);
    const_local_iterator unsafe_end(size_type n) const;
    const_local_iterator unsafe_cbegin(size_type n) const;
    const_local_iterator unsafe_cend(size_type n) const;

    // ハッシュポリシー
    float load_factor() const;
    float max_load_factor() const;
    void max_load_factor(float z);
    void rehash(size_type n);

`concurrent_unordered_set` のメンバー

public:
    // 構築、破棄、コピー
    explicit concurrent_unordered_set(size_type n = implementation-defined,
                                      const Hasher& hf = hasher(),
                                      const key_equal& eql = key_equal(),
                                      const allocator_type& a = allocator_type());
    template <typename InputIterator>
    concurrent_unordered_set(InputIterator first, InputIterator last,
                             size_type n = implementation-defined,
                             const hasher& hf = hasher(),
                             const key_equal& eql = key_equal(),
                             const allocator_type& a = allocator_type());
    concurrent_unordered_set(const concurrent_unordered_set&);
    concurrent_unordered_set(const Alloc&);
    concurrent_unordered_set(const concurrent_unordered_set&, const Alloc&);
    // C++11 仕様
    concurrent_unordered_set(concurrent_unordered_set&&);
    concurrent_unordered_set(concurrent_unordered_set&&, const Allocator&);
    concurrent_unordered_set(std::initializer_list<value_type> il,
                             size_type n = implementation-defined,
                             const Hasher& hf = hasher(),
                             const key_equal& eql = key_equal(),
                             const allocator_type& a = allocator_type());
    ~concurrent_unordered_set();

    concurrent_unordered_set& operator=(const concurrent_unordered_set&);
    // C++11 仕様
    concurrent_unordered_set& operator=(concurrent_unordered_set&&)
    concurrent_unordered_set& operator=(std::initializer_list<value_type> il);

    void swap(concurrent_unordered_set&);

`concurrent_unordered_multiset` のメンバー

public:
    // 構築、破棄、コピー
    explicit concurrent_unordered_multiset(size_type n = implementation-defined,
                                           const Hasher& hf = hasher(),
                                           const key_equal& eql = key_equal(),
                                           const allocator_type& a = allocator_type());
    template <typename InputIterator>
    concurrent_unordered_multiset(InputIterator first, InputIterator last,
                                  size_type n = implementation-defined,
                                  const hasher& hf = hasher(),
                                  const key_equal& eql = key_equal(),
                                  const allocator_type& a = allocator_type());
    concurrent_unordered_multiset(const concurrent_unordered_multiset&);
    concurrent_unordered_multiset(const Alloc&);
    concurrent_unordered_multiset(const concurrent_unordered_multiset&, const Alloc&);
    // C++11 仕様
    concurrent_unordered_multiset(concurrent_unordered_multiset&&);
    concurrent_unordered_multiset(concurrent_unordered_multiset&&, const Allocator&);
    concurrent_unordered_multiset(std::initializer_list<value_type> il,
                                  size_type n = implementation-defined,
                                  const Hasher& hf = hasher(),
                                  const key_equal& eql = key_equal(),
                                  const allocator_type& a = allocator_type());
    ~concurrent_unordered_multiset();

    concurrent_unordered_multiset& operator=(const concurrent_unordered_multiset&);
    // C++11 仕様
    concurrent_unordered_multiset& operator=(concurrent_unordered_multiset&&)
    concurrent_unordered_multiset& operator=(std::initializer_list<value_type> il);

    void swap(concurrent_unordered_multiset&);

`concurrent_unordered_set` テンプレート・クラスと `concurrent_unordered_multiset` テンプレート・クラス

概要

構文

ヘッダー

説明

注意

`concurrent_unordered_set` と `concurrent_unordered_multiset` の共通のメンバー

`concurrent_unordered_set` のメンバー

`concurrent_unordered_multiset` のメンバー

関連情報

concurrent_unordered_set テンプレート・クラスと concurrent_unordered_multiset テンプレート・クラス

概要

構文

ヘッダー

説明

注意

concurrent_unordered_set と concurrent_unordered_multiset の共通のメンバー

concurrent_unordered_set のメンバー

concurrent_unordered_multiset のメンバー

関連情報

`concurrent_unordered_set` テンプレート・クラスと `concurrent_unordered_multiset` テンプレート・クラス

`concurrent_unordered_set` と `concurrent_unordered_multiset` の共通のメンバー

`concurrent_unordered_set` のメンバー

`concurrent_unordered_multiset` のメンバー