Megosztás a következőn keresztül:

concurrent_unordered_map osztály

A concurrent_unordered_map osztály egy egyidejűségbiztos tároló, amely különböző hosszúságú, std::pair<const K, _Element_type>típusú elemek sorozatát vezérli. A szekvencia olyan módon jelenik meg, amely lehetővé teszi az egyidejűségmentes hozzáfűzést, az elemhozzáférést, az iterátor-hozzáférést és az iterátor-bejárási műveleteket. Itt az egyidejűség-biztonságos érték azt jelenti, hogy a mutató vagy az iterátor mindig érvényes. Ez nem garantálja az elemek inicializálását vagy egy adott bejárási sorrendet.

Szintaxis

template <typename K,
    typename _Element_type,
    typename _Hasher = std::hash<K>,
    typename key_equality = std::equal_to<K>,
    typename _Allocator_type = std::allocator<std::pair<const K, _Element_type>>>
class concurrent_unordered_map : public details::_Concurrent_hash<details::_Concurrent_unordered_map_traits<K, _Element_type, details::_Hash_compare<K, _Hasher, key_equality>, _Allocator_type, false>>;

Paraméterek

K
A kulcs típusa.

_Element_type
A megfeleltetett típus.

_Hasher
A kivonatfüggvény objektumtípusa. Ez az argumentum nem kötelező, és az alapértelmezett érték std::hash<K>.

key_equality
Az egyenlőségi összehasonlító függvény objektumtípusa. Ez az argumentum nem kötelező, és az alapértelmezett érték std::equal_to<K>.

_Allocator_type
Az a típus, amely az egyidejűleg rendezetlen térképhez tartozó memória lefoglalásával és felszabadítással kapcsolatos adatokat tartalmazó tárolt elosztó objektumot jelöli. Ez az argumentum nem kötelező, és az alapértelmezett érték std::allocator<std::pair<K, _Element_type>>.

Tagok

Nyilvános typedefs

Név Leírás
allocator_type A tárterület kezelésére szolgáló kiosztó típusa.
const_iterator A szabályozott sorozat állandó iterátorának típusa.
const_local_iterator A konstans gyűjtő iterátorának típusa a szabályozott sorozathoz.
const_pointer Az elemre mutató állandó mutató típusa.
const_reference Az elemre mutató állandó hivatkozás típusa.
difference_type A két elem közötti aláírt távolság típusa.
hasher A kivonatfüggvény típusa.
iterator A szabályozott sorozat iterátorának típusa.
key_equal Az összehasonlító függvény típusa.
key_type A rendelési kulcs típusa.
local_iterator A vezérelt sorozat gyűjtő iterátorának típusa.
mapped_type Az egyes kulcsokhoz társított megfeleltetett érték típusa.
pointer Az elemhez mutató mutató típusa.
reference Az elemre mutató hivatkozás típusa.
size_type A két elem közötti aláíratlan távolság típusa.
value_type Az elem típusa.

Nyilvános konstruktorok

Név Leírás
concurrent_unordered_map Túlterhelt. Egyidejű rendezetlen térképet hoz létre.

Nyilvános metódusok

Név Leírás
Túlterhelt. Egy adott kulcsértékkel rendelkező concurrent_unordered_map egyik elemének keresése. Ez a módszer egyidejűség-biztonságos.
hash_function Lekéri a tárolt kivonatfüggvény-objektumot.
beszúrása Túlterhelt. Elemeket ad hozzá a concurrent_unordered_map objektumhoz.
key_eq Lekéri a tárolt egyenlőség-összehasonlító függvény objektumát.
felcserélési Két concurrent_unordered_map objektum tartalmának felcserélése. Ez a módszer nem egyidejűségbiztos.
unsafe_erase Túlterhelt. Eltávolítja az elemeket a concurrent_unordered_map a megadott pozíciókban. Ez a módszer nem egyidejűségbiztos.

Nyilvános operátorok

Név Leírás
operátor[] Túlterhelt. Megkeres vagy beszúr egy elemet a megadott kulccsal. Ez a módszer egyidejűség-biztonságos.
operátor= Túlterhelt. Egy másik concurrent_unordered_map objektum tartalmát rendeli hozzá ehhez. Ez a módszer nem egyidejűségbiztos.

Megjegyzések

A concurrent_unordered_map osztályról további információt Párhuzamos tárolók és objektumokcímű témakörben talál.

Öröklési hierarchia

_Traits

_Concurrent_hash

concurrent_unordered_map

Követelmények

fejléc: concurrent_unordered_map.h

névtér: egyidejűség

nél

Egy adott kulcsértékkel rendelkező concurrent_unordered_map egyik elemének keresése. Ez a módszer egyidejűség-biztonságos.

mapped_type& at(const key_type& KVal);

const mapped_type& at(const key_type& KVal) const;

Paraméterek

KVal
A keresendő kulcsérték.

Visszaadott érték

Hivatkozás a talált elem adatértékére.

Megjegyzések

Ha az argumentumkulcs értéke nem található, a függvény a out_of_rangeosztály egy objektumát dobja.

kezdődik

Egy iterátort ad vissza, amely az egyidejű tároló első elemére mutat. Ez a módszer az egyidejűség biztonságos.

iterator begin();

const_iterator begin() const;

Visszaadott érték

Az egyidejű tároló első elemének iterátora.

cbegin

Egy konstans iterátort ad vissza, amely az egyidejű tároló első elemére mutat. Ez a módszer az egyidejűség biztonságos.

const_iterator cbegin() const;

Visszaadott érték

Konstans iterátor az egyidejű tároló első eleméhez.

cend

Egy konstans iterátort ad vissza, amely az egyidejű tároló utolsó elemét követő helyre mutat. Ez a módszer az egyidejűség biztonságos.

const_iterator cend() const;

Visszaadott érték

Egy konstans iterátor az egyidejű tároló utolsó elemét követő helyre.

világos

Törli az egyidejű tároló összes elemét. Ez a függvény nem biztonságos egyidejűség.

void clear();

concurrent_unordered_map

Egyidejű rendezetlen térképet hoz létre.

explicit concurrent_unordered_map(
    size_type _Number_of_buckets = 8,
    const hasher& _Hasher = hasher(),
    const key_equal& key_equality = key_equal(),
    const allocator_type& _Allocator = allocator_type());

concurrent_unordered_map(
    const allocator_type& _Allocator);

template <typename _Iterator>
concurrent_unordered_map(_Iterator _Begin,
    _Iterator _End,
    size_type _Number_of_buckets = 8,
    const hasher& _Hasher = hasher(),
    const key_equal& key_equality = key_equal(),
    const allocator_type& _Allocator = allocator_type());

concurrent_unordered_map(
    const concurrent_unordered_map& _Umap);

concurrent_unordered_map(
    const concurrent_unordered_map& _Umap,
    const allocator_type& _Allocator);

concurrent_unordered_map(
    concurrent_unordered_map&& _Umap);

Paraméterek

_Iterator
A bemeneti iterátor típusa.

_Number_of_buckets
A rendezetlen térkép gyűjtőinek kezdeti száma.

_Hasher
A rendezetlen térkép kivonatfüggvénye.

key_equality
A rendezetlen térkép egyenlőség-összehasonlító függvénye.

_Címfoglaló
A rendezetlen térkép kiosztója.

_Kezdődik
A másolandó elemek tartományának első elemének pozíciója.

_Vég
Az első elem helye a másolandó elemek tartományán túl.

_Umap
A forrás concurrent_unordered_map objektumot az elemek másolásához vagy áthelyezéséhez.

Megjegyzések

Minden konstruktor tárol egy allokátorobjektumot _Allocator, és inicializálja a rendezetlen térképet.

Az első konstruktor egy üres kezdeti térképet ad meg, és explicit módon megadja a használandó gyűjtők, kivonatfüggvények, egyenlőségfüggvények és kiosztótípusok számát.

A második konstruktor megadja a rendezetlen térkép kiosztását.

A harmadik konstruktor az iterátortartomány által megadott értékeket adja meg [ _Begin, _End).

A negyedik és az ötödik konstruktor az egyidejű rendezetlen térkép másolatát adja meg _Umap.

Az utolsó konstruktor az egyidejű rendezetlen térkép áthelyezését adja meg _Umap.

gróf

Megszámolja a megadott kulcsnak megfelelő elemek számát. Ez a függvény az egyidejűség biztonságos.

size_type count(const key_type& KVal) const;

Paraméterek

KVal
A keresendő kulcs.

Visszaadott érték

A kulcs hányszor jelenik meg a tárolóban.

üres

Ellenőrzi, hogy nincsenek-e elemek. Ez a módszer az egyidejűség biztonságos.

bool empty() const;

Visszaadott érték

true, ha az egyidejű tároló üres, false ellenkező esetben.

Megjegyzések

Egyidejű beszúrások esetén, hogy az egyidejű tároló üres-e, a függvény meghívása után azonnal megváltozhat, mielőtt a visszatérési érték beolvasható.

vég

Egy olyan iterátort ad vissza, amely az egyidejű tároló utolsó elemét követő helyre mutat. Ez a módszer az egyidejűség biztonságos.

iterator end();

const_iterator end() const;

Visszaadott érték

Az egyidejű tároló utolsó elemét követő iterátor.

equal_range

Megkeres egy megadott kulccsal egyező tartományt. Ez a függvény az egyidejűség biztonságos.

std::pair<iterator,
    iterator> equal_range(
    const key_type& KVal);

std::pair<const_iterator,
    const_iterator> equal_range(
    const key_type& KVal) const;

Paraméterek

KVal
A keresendő kulcsérték.

Visszaadott érték

Egy pár, ahol az első elem az elejétől egy iterátor, a második elem pedig egy iterátor a tartomány végéig.

Megjegyzések

Lehetséges, hogy az egyidejű beszúrások további kulcsokat is beszúrnak a kezdő iterátor és a záró iterátor előtt.

talál

Megkeres egy adott kulccsal egyező elemet. Ez a függvény az egyidejűség biztonságos.

iterator find(const key_type& KVal);

const_iterator find(const key_type& KVal) const;

Paraméterek

KVal
A keresendő kulcsérték.

Visszaadott érték

Egy iterátor, amely a megadott kulcsnak megfelelő első elem helyére mutat, vagy az iterátor end(), ha nincs ilyen elem.

get_allocator

Az egyidejű tároló tárolt kiosztóobjektumát adja vissza. Ez a módszer az egyidejűség biztonságos.

allocator_type get_allocator() const;

Visszaadott érték

Az egyidejű tároló tárolt kiosztóobjektuma.

hash_function

Lekéri a tárolt kivonatfüggvény-objektumot.

hasher hash_function() const;

Visszaadott érték

A tárolt kivonatfüggvény objektuma.

beilleszt

Elemeket ad hozzá a concurrent_unordered_map objektumhoz.

std::pair<iterator,
    bool> insert(
    const value_type& value);

iterator insert(
    const_iterator _Where,
    const value_type& value);

template<class _Iterator>
void insert(_Iterator first,
    _Iterator last);

template<class V>
std::pair<iterator,
    bool> insert(
    V&& value);

template<class V>
typename std::enable_if<!std::is_same<const_iterator,
    typename std::remove_reference<V>::type>::value,
    iterator>::type insert(
    const_iterator _Where,
    V&& value);

Paraméterek

_Iterator
A beszúráshoz használt iterátor típusa.

V
A térképbe beszúrt érték típusa.

érték
A beszúrandó érték.

_Hol
A beszúrási pont keresésének kezdő helye.

első
A beszúrni kívánt tartomány kezdete.

utolsó
A beszúrni kívánt tartomány vége.

Visszaadott érték

Egy iterátort és logikai értéket tartalmazó pár. További részletekért tekintse meg a Megjegyzések szakaszt.

Megjegyzések

Az első tagfüggvény határozza meg, hogy létezik-e X elem abban a sorrendben, amelynek kulcsának sorrendje megegyezik a valueéval. Ha nem, akkor létrehoz egy ilyen X elemet, és inicializálja azt value. A függvény ezután meghatározza az X-et meghatározó iterátort where. Ha beszúrás történt, a függvény std::pair(where, true)ad vissza. Ellenkező esetben std::pair(where, false)ad vissza.

A második tagfüggvény a insert(value) függvényt adja vissza, amely kezdőhelyként szolgál _Where a szabályozott sorrendben a beszúrási pont kereséséhez.

A harmadik tagfüggvény beszúrja az elemértékek sorozatát az [first, last) tartományból.

Az utolsó két tagfüggvény ugyanúgy viselkedik, mint az első kettő, kivéve, hogy value a beszúrt érték létrehozásához használatos.

key_eq

Lekéri a tárolt egyenlőség-összehasonlító függvény objektumát.

key_equal key_eq() const;

Visszaadott érték

A tárolt egyenlőség-összehasonlító függvény objektuma.

load_factor

Kiszámítja és visszaadja a tároló aktuális terhelési tényezőit. A terhelési tényező a tároló elemeinek száma a gyűjtők számával osztva.

float load_factor() const;

Visszaadott érték

A tároló terhelési tényezője.

max_load_factor

Lekéri vagy beállítja a tároló maximális terhelési tényezőjének értékét. A maximális terhelési tényező az elemek legnagyobb száma, mint bármely gyűjtőben, mielőtt a tároló növeli a belső táblát.

float max_load_factor() const;

void max_load_factor(float _Newmax);

Paraméterek

_Newmax

Visszaadott érték

Az első tagfüggvény a tárolt maximális terhelési tényezőt adja vissza. A második tagfüggvény nem ad vissza értéket, hanem out_of_range kivételt ad vissza, ha a megadott terhelési tényező érvénytelen.

maximális méret

Az egyidejű tároló maximális méretét adja vissza, amelyet az elosztó határoz meg. Ez a módszer az egyidejűség biztonságos.

size_type max_size() const;

Visszaadott érték

Az egyidejű tárolóba beszúrható elemek maximális száma.

Megjegyzések

Ez a felső határérték valójában magasabb lehet, mint amit a tároló ténylegesen tárolhat.

operátor[]

Megkeres vagy beszúr egy elemet a megadott kulccsal. Ez a módszer egyidejűség-biztonságos.

mapped_type& operator[](const key_type& kval);

mapped_type& operator[](key_type&& kval);

Paraméterek

KVal
A kulcs értéke a következőhöz:

keresés vagy beszúrás.

Visszaadott érték

Hivatkozás a talált vagy beszúrt elem adatértékére.

Megjegyzések

Ha az argumentumkulcs értéke nem található, akkor a rendszer beszúrja az adattípus alapértelmezett értékével együtt.

operator[] segítségével elemeket szúrhat be egy térképbe mm[key] = DataValue;használatával , ahol a DataValue az elem mapped_type értéke, amelynek kulcsértéke key.

Ha operator[] használ elemek beszúrására, a visszaadott hivatkozás nem jelzi, hogy egy beszúrás módosítja-e a meglévő elemet, vagy újat hoz létre. A tagfüggvények find és beszúrási segítségével megállapítható, hogy egy adott kulccsal rendelkező elem már megtalálható-e a beszúrás előtt.

operátor=

Egy másik concurrent_unordered_map objektum tartalmát rendeli hozzá ehhez. Ez a módszer nem egyidejűségbiztos.

concurrent_unordered_map& operator= (const concurrent_unordered_map& _Umap);

concurrent_unordered_map& operator= (concurrent_unordered_map&& _Umap);

Paraméterek

_Umap
A forrás concurrent_unordered_map objektum.

Visszaadott érték

Hivatkozás erre a concurrent_unordered_map objektumra.

Megjegyzések

A meglévő elemek egyidejű vektorának törlése után operator= másolhatja vagy áthelyezheti a _Umap tartalmát az egyidejű vektorba.

Felmelegít

Újraépíti a kivonattáblát.

void rehash(size_type _Buckets);

Paraméterek

_Vödör
A gyűjtők kívánt száma.

Megjegyzések

A tagfüggvény módosítja a legalább _Buckets gyűjtők számát, és szükség szerint újraépíti a kivonattáblát. A gyűjtők számának 2-esnek kell lennie. Ha nem 2-es hatvány, akkor a következő legnagyobb 2-es teljesítményre lesz kerekítve.

Kivételt out_of_range, ha a gyűjtők száma érvénytelen (vagy 0 vagy nagyobb, mint a gyűjtők maximális száma).

méret

Az egyidejű tároló elemeinek számát adja vissza. Ez a módszer az egyidejűség biztonságos.

size_type size() const;

Visszaadott érték

A tárolóban lévő elemek száma.

Megjegyzések

Egyidejű beszúrások esetén az egyidejű tároló elemeinek száma a függvény meghívása után azonnal megváltozhat, mielőtt a visszatérési érték beolvasható.

elcserél

Két concurrent_unordered_map objektum tartalmának felcserélése. Ez a módszer nem egyidejűségbiztos.

void swap(concurrent_unordered_map& _Umap);

Paraméterek

_Umap
A concurrent_unordered_map objektum, amellyel felcserélhet.

unsafe_begin

Egy iterátort ad vissza a tároló első eleméhez egy adott gyűjtőhöz.

local_iterator unsafe_begin(size_type _Bucket);

const_local_iterator unsafe_begin(size_type _Bucket) const;

Paraméterek

_Vödör
A gyűjtő indexe.

Visszaadott érték

A gyűjtő elejére mutató iterátor.

unsafe_bucket

Visszaadja azt a gyűjtőindexet, amelyet egy adott kulcs leképz ebben a tárolóban.

size_type unsafe_bucket(const key_type& KVal) const;

Paraméterek

KVal
A keresett elemkulcs.

Visszaadott érték

A tároló kulcsának gyűjtőindexe.

unsafe_bucket_count

A tárolóban lévő gyűjtők aktuális számát adja vissza.

size_type unsafe_bucket_count() const;

Visszaadott érték

A tárolóban lévő gyűjtők aktuális száma.

unsafe_bucket_size

A tároló egy adott gyűjtőjében lévő elemek számát adja vissza.

size_type unsafe_bucket_size(size_type _Bucket);

Paraméterek

_Vödör
A keresendő gyűjtő.

Visszaadott érték

A tárolóban lévő gyűjtők aktuális száma.

unsafe_cbegin

Egy iterátort ad vissza a tároló első eleméhez egy adott gyűjtőhöz.

const_local_iterator unsafe_cbegin(size_type _Bucket) const;

Paraméterek

_Vödör
A gyűjtő indexe.

Visszaadott érték

A gyűjtő elejére mutató iterátor.

unsafe_cend

Egy iterátort ad vissza egy adott gyűjtő utolsó elemét követő helyre.

const_local_iterator unsafe_cend(size_type _Bucket) const;

Paraméterek

_Vödör
A gyűjtő indexe.

Visszaadott érték

A gyűjtő elejére mutató iterátor.

unsafe_end

Egy iterátort ad vissza a tároló utolsó eleméhez egy adott gyűjtőhöz.

local_iterator unsafe_end(size_type _Bucket);

const_local_iterator unsafe_end(size_type _Bucket) const;

Paraméterek

_Vödör
A gyűjtő indexe.

Visszaadott érték

Egy iterátor, amely a gyűjtő végére mutat.

unsafe_erase

Eltávolítja az elemeket a concurrent_unordered_map a megadott pozíciókban. Ez a módszer nem egyidejűségbiztos.

iterator unsafe_erase(
    const_iterator _Where);

iterator unsafe_erase(
    const_iterator _Begin,
    const_iterator _End);

size_type unsafe_erase(
    const key_type& KVal);

Paraméterek

_Hol
A törölni kívánt iterátorpozíció.

_Kezdődik
A törölni kívánt elemek tartományának első elemének pozíciója.

_Vég
Az első elem pozíciója a törölni kívánt elemek tartományán túl.

KVal
A törölni kívánt kulcsérték.

Visszaadott érték

Az első két tagfüggvény egy iterátort ad vissza, amely kijelöli az eltávolított elemeken kívül fennmaradó első elemet, vagy concurrent_unordered_map::end() ha nincs ilyen elem. A harmadik tagfüggvény az eltávolított elemek számát adja vissza.

Megjegyzések

Az első tagfüggvény eltávolítja a _Whereáltal mutatott szabályozott sorozat elemét. A második tagfüggvény eltávolítja a tartomány elemeit [ _Begin, _End).

A harmadik tagfüggvény eltávolítja a concurrent_unordered_map::equal_range(KVal) által tagolt tartomány elemeit.

unsafe_max_bucket_count

A tárolóban lévő gyűjtők maximális számát adja vissza.

size_type unsafe_max_bucket_count() const;

Visszaadott érték

A tárolóban lévő gyűjtők maximális száma.

Lásd még:

egyidejű névtér
párhuzamos tárolók és objektumok

  • Last updated on