hash_multiset (STL/CLR)

Die Vorlagenklasse beschreibt ein Objekt, das eine unterschiedliche Sequenz von Elementen steuert, die bidirektionalen Zugriff haben. Sie verwenden den Container hash_multiset , um eine Abfolge von Elementen als Hashtabelle zu verwalten, jeder Tabelleneintrag, der eine bidirektionale verknüpfte Liste von Knoten speichert, und jeder Knoten, der ein Element speichert. Der Wert jedes Elements wird als Schlüssel verwendet, um die Sequenz zu sortieren.

In der nachstehenden Beschreibung ist die gleiche GKeywie , die wiederum mit "Key" identisch ist, GValue es sei denn, dies ist ein Bezugstyp, in diesem Fall ist Key^es .

Syntax

template<typename Key>
    ref class hash_multiset
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IHash<Gkey, GValue>
    { ..... };

Parameter

Schlüssel
Der Typ der Schlüsselkomponente eines Elements in der kontrollierten Sequenz.

Anforderungen

Header:< cliext/hash_set>

Namespace: cliext

Deklarationen

Typendefinition	Beschreibung
hash_multiset::const_iterator (STL/CLR)	Der Typ eines konstanten Iterators für die gesteuerte Sequenz.
hash_multiset::const_reference (STL/CLR)	Der Typ eines konstanten Verweises auf ein Element.
hash_multiset::const_reverse_iterator (STL/CLR)	Der Typ eines konstanten umgekehrten Iterators für die gesteuerte Sequenz.
hash_multiset::difference_type (STL/CLR)	Der Typ eines (möglicherweise signierten) Abstands zwischen zwei Elementen.
hash_multiset::generic_container (STL/CLR)	Der Typ der generischen Schnittstelle für den Container.
hash_multiset::generic_iterator (STL/CLR)	Der Typ eines Iterators für die generische Schnittstelle für den Container.
hash_multiset::generic_reverse_iterator (STL/CLR)	Der Typ eines Reverse-Iterators für die generische Schnittstelle für den Container.
hash_multiset::generic_value (STL/CLR)	Der Typ eines Elements für die generische Schnittstelle für den Container.
hash_multiset::hasher (STL/CLR)	Der Hashingstellvertretung für einen Schlüssel.
hash_multiset::iterator (STL/CLR)	Der Typ eines Iterators für die gesteuerte Sequenz.
hash_multiset::key_compare (STL/CLR)	Der Sortierstellvertretung für zwei Schlüssel.
hash_multiset::key_type (STL/CLR)	Der Typ eines Sortierschlüssels.
hash_multiset::reference (STL/CLR)	Der Typ eines Verweises auf ein Element.
hash_multiset::reverse_iterator (STL/CLR)	Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz.
hash_multiset::size_type (STL/CLR)	Der Typ eines (nicht negativen) Abstands zwischen zwei Elementen.
hash_multiset::value_compare (STL/CLR)	Der Sortierstellvertretung für zwei Elementwerte.
hash_multiset::value_type (STL/CLR)	Der Typ eines Elements.

Memberfunktion	BESCHREIBUNG
hash_multiset::begin (STL/CLR)	Legt den Anfang der kontrollierten Sequenz fest.
hash_multiset::bucket_count (STL/CLR)	Zählt die Anzahl der Buckets.
hash_multiset::clear (STL/CLR)	Entfernt alle Elemente.
hash_multiset::count (STL/CLR)	Zählt Elemente, die einem angegebenen Schlüssel entsprechen.
hash_multiset::empty (STL/CLR)	Testet, ob keine Elemente vorhanden sind.
hash_multiset::end (STL/CLR)	Legt das Ende der kontrollierten Sequenz fest.
hash_multiset::equal_range (STL/CLR)	Sucht den Bereich, der einem angegebenen Schlüssel entspricht.
hash_multiset::erase (STL/CLR)	Entfernt Elemente an den angegebenen Positionen.
hash_multiset::find (STL/CLR)	Sucht ein Element, das einem angegebenen Schlüssel entspricht.
hash_multiset::hash_delegate (STL/CLR)	Kopiert den Hashingstellvertretung für einen Schlüssel.
hash_multiset::hash_multiset (STL/CLR)	Erstellt ein container-Objekt.
hash_multiset::insert (STL/CLR)	Fügt Elemente hinzu.
hash_multiset::key_comp (STL/CLR)	Kopiert den Sortierstellvertretung für zwei Schlüssel.
hash_multiset::load_factor (STL/CLR)	Zählt die durchschnittliche Anzahl von Elementen pro Bucket.
hash_multiset::lower_bound (STL/CLR)	Sucht den Anfang des Bereichs, der einem angegebenen Schlüssel entspricht.
hash_multiset::make_value (STL/CLR)	Erstellt ein Wertobjekt.
hash_multiset::max_load_factor (STL/CLR)	Ruft die maximale Anzahl von Elementen pro Bucket ab oder legt sie fest.
hash_multiset::rbegin (STL/CLR)	Legt den Anfang der umgekehrten kontrollierten Sequenz fest.
hash_multiset::rehash (STL/CLR)	Erstellt die Hashtabelle neu.
hash_multiset::rend (STL/CLR)	Legt das Ende der umgekehrten kontrollierten Sequenz fest.
hash_multiset::size (STL/CLR)	Ermittelt die Anzahl von Elementen.
hash_multiset::swap (STL/CLR)	Vertauscht den Inhalt von zwei Containern.
hash_multiset::to_array (STL/CLR)	Kopiert die kontrollierte Sequenz in ein neues Array.
hash_multiset::upper_bound (STL/CLR)	Findet ende des Bereichs, der einem angegebenen Schlüssel entspricht.
hash_multiset::value_comp (STL/CLR)	Kopiert den Bestellstellvertretung für zwei Elementwerte.

Operator	BESCHREIBUNG
hash_multiset::operator= (STL/CLR)	Ersetzt die kontrollierte Sequenz.

Schnittstellen

Schnittstelle	BESCHREIBUNG
ICloneable	Duplizieren eines Objekts.
IEnumerable	Sequenzieren durch Elemente.
ICollection	Verwalten der Gruppe von Elementen.
IEnumerable<T>	Sequenz über eingegebene Elemente.
ICollection<T>	Verwalten der Gruppe der typierten Elemente.
IHashKey<, Wert>	Behalten Sie den generischen Container bei.

Hinweise

Das Objekt weist den Speicher für die Sequenz zu, die er als einzelne Knoten in einer bidirektionalen verknüpften Liste steuert. Um den Zugriff zu beschleunigen, verwaltet das Objekt auch ein unterschiedliches Array von Zeigern in die Liste (die Hashtabelle), verwaltet die gesamte Liste effektiv als Sequenz von Unterlisten oder Buckets. Es fügt Elemente in einen Bucket ein, der sortiert wird, indem er die Verknüpfungen zwischen Knoten ändert, niemals durch Kopieren des Inhalts eines Knotens in einen anderen. Das bedeutet, dass Sie Elemente frei einfügen und entfernen können, ohne verbleibende Elemente zu stören.

Das Objekt bestellt jeden Bucket, den er steuert, indem ein gespeichertes Stellvertretungsobjekt vom Typ hash_set::key_compare (STL/CLR) aufgerufen wird. Sie können das gespeicherte Stellvertretungsobjekt angeben, wenn Sie das hash_set erstellen; Wenn Sie kein Stellvertretungsobjekt angeben, ist der Standard der Vergleich operator<=(key_type, key_type).

Sie greifen auf das gespeicherte Stellvertretungsobjekt zu, indem Sie die Memberfunktion hash_set::key_comp (STL/CLR)() aufrufen. Ein solches Stellvertretungsobjekt muss die entsprechende Reihenfolge zwischen Schlüsseln des Typs hash_set::key_type (STL/CLR) definieren. Das bedeutet, dass für alle zwei Schlüssel X und Y:

key_comp()(X, Y) gibt das gleiche boolesche Ergebnis für jeden Aufruf zurück.

Wenn key_comp()(X, Y) && key_comp()(Y, X) dies wahr ist, X dann und Y müssen die entsprechende Reihenfolge haben.

Jede Ordnungsregel, die sich wie operator<=(key_type, key_type)operator>=(key_type, key_type) verhält oder operator==(key_type, key_type) die eqivalente Reihenfolge definiert.

Beachten Sie, dass der Container nur dafür sorgt, dass Elemente, deren Schlüssel die entsprechende Reihenfolge aufweisen (und welche Hash auf den gleichen ganzzahligen Wert) innerhalb eines Buckets liegen. Im Gegensatz zur Vorlagenklasse hash_set (STL/CLR) erfordert ein Objekt der Vorlagenklasse hash_multiset nicht, dass schlüssel für alle Elemente eindeutig sind. (Zwei oder mehr Schlüssel können eine entsprechende Reihenfolge aufweisen.)

Das Objekt bestimmt, welche Bucket einen bestimmten Bestellschlüssel enthalten soll, indem ein gespeichertes Stellvertretungsobjekt vom Typ hash_set::hasher (STL/CLR) aufgerufen wird. Sie greifen auf dieses gespeicherte Objekt zu, indem Sie die Memberfunktion hash_set::hash_delegate (STL/CLR)() aufrufen, um einen ganzzahligen Wert abzurufen, der vom Schlüsselwert abhängt. Sie können das gespeicherte Stellvertretungsobjekt angeben, wenn Sie das hash_set erstellen; Wenn Sie kein Stellvertretungsobjekt angeben, ist die Standardfunktion die Funktion System::Object::hash_value(key_type). Das bedeutet, dass für alle Schlüssel X und Y:

hash_delegate()(X) gibt das gleiche ganze Ergebnis für jeden Aufruf zurück.

Wenn X und Y über eine entsprechende Reihenfolge verfügen, hash_delegate()(X) sollte das gleiche ganze Ergebnis wie hash_delegate()(Y).

Jedes Element dient sowohl als Schlüssel als auch als Wert. Die Sequenz wird in einer Weise dargestellt, die die Nachschlage-, Einfüge- und Entfernung eines beliebigen Elements mit einer Reihe von Vorgängen ermöglicht, die unabhängig von der Anzahl der Elemente in der Sequenz (Konstantenzeit) sind - zumindest in den besten Fällen. Darüber hinaus führt das Einfügen eines Elements nicht dazu, dass Iteratoren ungültig werden, und durch das Entfernen eines Elements werden nur solche Iteratoren ungültig, die auf das entfernte Element gezeigt haben.

Wenn Hashwerte nicht einheitlich verteilt werden, kann jedoch eine Hashtabelle degeneriert werden. Im Extrem -- für eine Hashfunktion, die immer denselben Wert zurückgibt -- Nachschlage-, Einfüge- und Entfernung sind proportional zur Anzahl der Elemente in der Sequenz (lineare Zeit). Der Container bemüht sich, eine angemessene Hashfunktion, mittlere Bucketgröße und Hashtabellengröße (Gesamtanzahl der Buckets) auszuwählen, aber Sie können alle diese Optionen außer Kraft setzen. Siehe z. B. die Funktionen hash_set::max_load_factor (STL/CLR) undhash_set::rehash (STL/CLR).

Ein hash_multiset unterstützt bidirektionale Iteratoren, was bedeutet, dass Sie zu benachbarten Elementen wechseln können, die einen Iterator geben, der ein Element in der kontrollierten Sequenz bestimmt. Ein spezieller Kopfknoten entspricht dem von hash_multiset::end (STL/CLR)() zurückgegebenen Iterator. Sie können diesen Iterator decrementieren, um das letzte Element in der kontrollierten Sequenz zu erreichen, falls vorhanden. Sie können einen hash_multiset Iterator erhöhen, um den Kopfknoten zu erreichen, und es wird dann gleich end()verglichen. Aber Sie können den von ihnen zurückgegebenen end()Iterator nicht ableiten.

Beachten Sie, dass Sie sich nicht direkt auf ein hash_multiset-Element beziehen können, das die numerische Position zugewiesen hat – dies erfordert eine zufällige Zugriffs-Iterator.

Ein hash_multiset Iterator speichert einen Handle an seinem zugeordneten hash_multiset Knoten, der wiederum einen Handle in seinem zugeordneten Container speichert. Sie können Iteratoren nur mit ihren zugeordneten Containerobjekten verwenden. Ein hash_multiset Iterator bleibt gültig, solange der zugeordnete hash_multiset-Knoten einigen hash_multiset zugeordnet ist. Darüber hinaus ist ein gültiger Iterator dereferencable -- Sie können es verwenden, um auf den angegebenen Elementwert zuzugreifen oder zu ändern - solange es nicht gleich end()ist.

Das Löschen oder Entfernen eines Elements ruft den Destruktor für seinen gespeicherten Wert auf. Durch das Zerstören des Containers werden alle Elemente gelöscht. Daher stellt ein Container, dessen Elementtyp eine Ref-Klasse ist, sicher, dass keine Elemente den Container ausleben. Beachten Sie jedoch, dass ein Container von Handlen seine Elemente nicht zerstört.

Member

hash_multiset::begin (STL/CLR)

Legt den Anfang der kontrollierten Sequenz fest.

Syntax

iterator begin();

Hinweise

Die Memberfunktion gibt einen bidirektionalen Iterator zurück, der das erste Element der kontrollierten Sequenz oder direkt über das Ende einer leeren Sequenz bestimmt. Sie können damit einen Iterator abrufen, der den current Anfang der kontrollierten Sequenz bestimmt; der Zustand kann sich jedoch ändern, sobald sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_hash_multiset_begin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_multiset::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);
    return (0);
    }

a b c
*begin() = a
*++begin() = b

hash_multiset::bucket_count (STL/CLR)

Zählt die Anzahl der Buckets.

Syntax

int bucket_count();

Hinweise

Die Memberfunktionen gibt die aktuelle Anzahl von Buckets zurück. Sie verwenden es, um die Größe der Hashtabelle zu bestimmen.

Beispiel

// cliext_hash_multiset_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_multiset::clear (STL/CLR)

Entfernt alle Elemente.

Syntax

void clear();

Hinweise

Die Memberfunktion ruft effektiv hash_multiset::erase (STL/CLR)hash_multiset::begin (STL/CLR)hash_multiset::End (STL/CLR)())((), auf. Sie verwenden es, um sicherzustellen, dass die kontrollierte Sequenz leer ist.

Beispiel

// cliext_hash_multiset_clear.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    // add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

hash_multiset::const_iterator (STL/CLR)

Der Typ eines konstanten Iterators für die gesteuerte Sequenz.

Syntax

typedef T2 const_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T2 , das als konstanter bidirektionaler Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_hash_multiset_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    Myhash_multiset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_multiset::const_reference (STL/CLR)

Der Typ eines konstanten Verweises auf ein Element.

Syntax

typedef value_type% const_reference;

Hinweise

Der Typ beschreibt einen Konstantenverweis auf ein Element.

Beispiel

// cliext_hash_multiset_const_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    Myhash_multiset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myhash_multiset::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_multiset::const_reverse_iterator (STL/CLR)

Der Typ einer konstanten Umgekehrten iterator für die kontrollierte Sequenz..

Syntax

typedef T4 const_reverse_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T4 , das als konstanter Umgekehrter Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_hash_multiset_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" reversed
    Myhash_multiset::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

hash_multiset::count (STL/CLR)

Sucht die Anzahl von Elementen, die einem angegebenen Schlüssel entsprechen.

Syntax

size_type count(key_type key);

Parameter

key
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktion gibt die Anzahl der Elemente in der kontrollierten Sequenz zurück, die die entsprechende Reihenfolge mit schlüsseln. Damit können Sie die Anzahl der Elemente in der kontrollierten Sequenz ermitteln, die derzeit einem angegebenen Schlüssel entsprechen.

Beispiel

// cliext_hash_multiset_count.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }

a b c
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

hash_multiset::difference_type (STL/CLR)

Die Typen eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int difference_type;

Hinweise

Der Typ beschreibt eine möglicherweise negative Elementanzahl.

Beispiel

// cliext_hash_multiset_difference_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_multiset::difference_type diff = 0;
    for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Myhash_multiset::iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3
begin()-end() = -3

hash_multiset::empty (STL/CLR)

Testet, ob keine Elemente vorhanden sind.

Syntax

bool empty();

Hinweise

Die Memberfunktion gibt „true“ für eine leere gesteuerte Sequenz zurück. Es entspricht hash_multiset::Size (STL/CLR)() == 0. Sie verwenden es, um zu testen, ob die hash_multiset leer ist.

Beispiel

// cliext_hash_multiset_empty.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

a b c
size() = 3
empty() = False
size() = 0
empty() = True

hash_multiset::end (STL/CLR)

Legt das Ende der kontrollierten Sequenz fest.

Syntax

iterator end();

Hinweise

Die Memberfunktion gibt einen bidirektionalen Iterator zurück, der direkt über das Ende der kontrollierten Sequenz verweist. Sie verwenden es, um einen Iterator zu erhalten, der das Ende der kontrollierten Sequenz bestimmt; der Status ändert sich nicht, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_hash_multiset_end.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last two items
    Myhash_multiset::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);
    return (0);
    }

a b c
*-- --end() = b
*--end() = c

hash_multiset::equal_range (STL/CLR)

Sucht den Bereich, der einem angegebenen Schlüssel entspricht.

Syntax

cliext::pair<iterator, iterator> equal_range(key_type key);

Parameter

key
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktion gibt ein Paar von Iteratoren cliext::pair<iterator, iterator>(hash_multiset::lower_bound (STL/CLR)hash_multiset::upper_bound (STL/CLR)(key),(key)) zurück. Sie verwenden es, um den Bereich von Elementen zu bestimmen, die derzeit in der kontrollierten Sequenz mit einem angegebenen Schlüssel übereinstimmen.

Beispiel

// cliext_hash_multiset_equal_range.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
typedef Myhash_multiset::pair_iter_iter Pairii;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display results of failed search
    Pairii pair1 = c1.equal_range(L'x');
    System::Console::WriteLine("equal_range(L'x') empty = {0}",
        pair1.first == pair1.second);

    // display results of successful search
    pair1 = c1.equal_range(L'b');
    for (; pair1.first != pair1.second; ++pair1.first)
        System::Console::Write("{0} ", *pair1.first);
    System::Console::WriteLine();
    return (0);
    }

a b c
equal_range(L'x') empty = True
b

hash_multiset::erase (STL/CLR)

Entfernt Elemente an den angegebenen Positionen.

Syntax

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)

Parameter

first
Anfang des Zu löschenden Bereichs.

key
Schlüsselwert zum Löschen.

last
Ende des Bereichs zum Löschen.

where
Element, das gelöscht werden soll.

Hinweise

Die erste Memberfunktion entfernt das Element der kontrollierten Sequenz, die auf die Stelle verweist, und gibt einen Iterator zurück, der das erste Element angibt, das über das element entfernt oder hash_multiset::End (STL/CLR)() verfügt, wenn kein solches Element vorhanden ist. Sie verwenden es, um ein einzelnes Element zu entfernen.

Die zweite Memberfunktion entfernt die Elemente der kontrollierten Sequenz im Bereich [first, last), und gibt einen Iterator zurück, der das erste Element angibt, das über alle Elemente hinaus entfernt bleibt, oder end() wenn kein solches Element vorhanden ist.. Sie verwenden es, um null oder mehr zusammenhängende Elemente zu entfernen.

Die dritte Memberfunktion entfernt alle Elemente der kontrollierten Sequenz, deren Schlüssel die entsprechende Reihenfolge aufweist, und gibt eine Anzahl der entfernten Elemente zurück. Sie verwenden es, um alle Elemente zu entfernen und zu zählen, die einem angegebenen Schlüssel entsprechen.

Jede Elementlöschung dauert Zeit proportional zum Logarithmus der Anzahl der Elemente in der kontrollierten Sequenz.

Beispiel

// cliext_hash_multiset_erase.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

    // add elements and display " b c d e"
    c1.insert(L'd');
    c1.insert(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase all but end
    Myhash_multiset::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

hash_multiset::find (STL/CLR)

Sucht ein Element, das einem angegebenen Schlüssel entspricht.

Syntax

iterator find(key_type key);

Parameter

key
Der zu suchende Schlüsselwert.

Hinweise

Wenn mindestens ein Element in der kontrollierten Sequenz eine gleichwertige Reihenfolge mit Schlüssel aufweist, gibt die Memberfunktion einen Iterator zurück, der eine dieser Elemente bestimmt; andernfalls wird hash_multiset::End (STL/CLR)() zurückgegeben. Sie verwenden es, um ein Element zu suchen, das derzeit in der kontrollierten Sequenz mit einem angegebenen Schlüssel übereinstimmt.

Beispiel

// cliext_hash_multiset_find.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());
    System::Console::WriteLine("find {0} = {1}",
        L'b', *c1.find(L'b'));
    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }

a b c
find A = False
find b = b
find C = False

hash_multiset::generic_container (STL/CLR)

Der Typ der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::
    IHash<GKey, GValue>
    generic_container;

Hinweise

Der Typ beschreibt die generische Schnittstelle für diese Vorlagencontainerklasse.

Beispiel

// cliext_hash_multiset_generic_container.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(L'e');
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

hash_multiset::generic_iterator (STL/CLR)

Der Typ eines Iterators für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

Hinweise

Der Typ beschreibt einen generischen Iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.

Beispiel

// cliext_hash_multiset_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_multiset::generic_iterator gcit = gc1->begin();
    Myhash_multiset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

hash_multiset::generic_reverse_iterator (STL/CLR)

Der Typ eines Reverse-Iterators für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value>
    generic_reverse_iterator;

Hinweise

Der Typ beschreibt einen generischen Reverse-Iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.

Beispiel

// cliext_hash_multiset_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_multiset::generic_reverse_iterator gcit = gc1->rbegin();
    Myhash_multiset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
c

hash_multiset::generic_value (STL/CLR)

Der Typ eines Elements für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef GValue generic_value;

Hinweise

Der Typ beschreibt ein Objekt des Typs GValue , das den gespeicherten Elementwert beschreibt, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet wird.

Beispiel

// cliext_hash_multiset_generic_value.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multiset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_multiset::generic_iterator gcit = gc1->begin();
    Myhash_multiset::generic_value gcval = *gcit;
    System::Console::WriteLine("{0} ", gcval);
    return (0);
    }

a b c
a b c
a

hash_multiset::hash_delegate (STL/CLR)

Sucht ein Element, das einem angegebenen Schlüssel entspricht.

Syntax

hasher^ hash_delegate();

Hinweise

Die Memberfunktion gibt den Stellvertretung zurück, der zum Konvertieren eines Schlüsselwerts in eine ganze Zahl verwendet wird. Sie verwenden es, um einen Schlüssel zu hashen.

Beispiel

// cliext_hash_multiset_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }

hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_multiset::hash_multiset (STL/CLR)

Erstellt ein container-Objekt.

Syntax

hash_multiset();
explicit hash_multiset(key_compare^ pred);
hash_multiset(key_compare^ pred, hasher^ hashfn);
hash_multiset(hash_multiset<Key>% right);
hash_multiset(hash_multiset<Key>^ right);
template<typename InIter>
    hash_multiset(InIter first, InIter last);
template<typename InIter>
    hash_multiset(InIter first, InIter last,
        key_compare^ pred);
template<typename InIter>
    hash_multiset(InIter first, InIter last,
        key_compare^ pred, hasher^ hashfn);
hash_multiset(System::Collections::Generic::IEnumerable<GValue>^ right);
hash_multiset(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);
hash_multiset(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred, hasher^ hashfn);

Parameter

first
Anfang des zu einfügenden Bereichs.

Hashfn
Hashfunktion für die Zuordnung von Schlüsseln zu Buckets.

last
Ende des zu einfügenden Bereichs.

Pred
Bestell prädikat für die kontrollierte Sequenz.

right
Einzufügendes Objekt bzw. einzufügender Bereich.

Hinweise

Der Konstruktor:

hash_multiset();

initialisiert die kontrollierte Sequenz ohne Elemente, mit dem Standardreihenfolge-Prädikat key_compare()und mit der Standard-Hashfunktion. Sie verwenden es, um eine leere anfängliche kontrollierte Sequenz mit der Standardreihenfolge und Hashfunktion anzugeben.

Der Konstruktor:

explicit hash_multiset(key_compare^ pred);

initialisiert die kontrollierte Sequenz ohne Elemente, mit der Reihenfolge prädikat pred und mit der Standard-Hashfunktion. Sie verwenden es, um eine leere anfängliche kontrollierte Sequenz anzugeben, wobei die angegebene Reihenfolge prädikat und die Standard-Hashfunktion angegeben werden.

Der Konstruktor:

hash_multiset(key_compare^ pred, hasher^ hashfn);

initialisiert die kontrollierte Sequenz ohne Elemente, mit der Reihenfolge prädikat pred und mit der Hashfunktion Hashfn. Sie verwenden es, um eine leere anfängliche kontrollierte Sequenz mit der angegebenen Prädikat- und Hashfunktion anzugeben.

Der Konstruktor:

hash_multiset(hash_multiset<Key>% right);

initialisiert die kontrollierte Sequenz mit der Sequenz [right.begin(), right.end()), mit dem Standardreihenfolge-Prädikat und mit der Standardhashfunktion. Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der Sequenz ist, die von dem hash_multiset-Objekt rechts gesteuert wird, mit der Standardreihenfolge-Prädikat- und Hashfunktion.

Der Konstruktor:

hash_multiset(hash_multiset<Key>^ right);

initialisiert die kontrollierte Sequenz mit der Sequenz [right->begin(), right->end()), mit dem Standardreihenfolge-Prädikat und mit der Standardhashfunktion. Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der Sequenz ist, die von dem hash_multiset-Objekt rechts gesteuert wird, mit der Standardreihenfolge-Prädikat- und Hashfunktion.

Der Konstruktor:

template<typename InIter> hash_multiset(InIter first, InIter last);

initialisiert die kontrollierte Sequenz mit der Sequenz [first, last), mit dem Standardreihenfolge-Prädikat und mit der Standardhashfunktion. Sie verwenden es, um die kontrollierte Sequenz eine Kopie einer anderen Sequenz mit der Standardreihenfolge-Prädikat- und Hashfunktion zu erstellen.

Der Konstruktor:

template<typename InIter> hash_multiset(InIter first, InIter last, key_compare^ pred);

initialisiert die kontrollierte Sequenz mit der Sequenz [first, last), mit dem Prädikat der Reihenfolge und mit der Standard-Hashfunktion. Sie verwenden es, um die kontrollierte Sequenz eine Kopie einer anderen Sequenz mit der angegebenen Reihenfolge-Prädikat und der Standard-Hashfunktion zu erstellen.

Der Konstruktor:

template<typename InIter> hash_multiset(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);

initialisiert die kontrollierte Sequenz mit der Sequenz [first, last), mit der Reihenfolge prädikat pred und mit der Hashfunktion Hashfn. Sie verwenden es, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz mit der angegebenen Reihenfolge-Prädikat- und Hashfunktion zu machen.

Der Konstruktor:

hash_multiset(System::Collections::Generic::IEnumerable<Key>^ right);

initialisiert die kontrollierte Sequenz mit der sequenz, die vom Enumerator rechts festgelegt ist, mit dem Standardreihenfolge-Prädikat und mit der Standardhashfunktion. Sie verwenden es, um die kontrollierte Sequenz eine Kopie einer anderen Sequenz zu erstellen, die von einer Aufzählung beschrieben wird, wobei die Standardreihenfolge Prädikat und Hashfunktion verwendet wird.

Der Konstruktor:

hash_multiset(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);

initialisiert die kontrollierte Sequenz mit der sequenz, die vom Enumerator rechts festgelegt ist, mit der Reihenfolge Prädikat pred und mit der Standard-Hashfunktion. Sie verwenden es, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu erstellen, die von einer Aufzählung beschrieben wird, wobei die angegebene Reihenfolge Prädikat- und Standardhashfunktion angegeben ist.

Der Konstruktor:

hash_multiset(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred, hasher^ hashfn);

initialisiert die kontrollierte Sequenz mit der sequenz, die vom Enumerator rechts festgelegt ist, mit der Reihenfolge prädikat pred und mit der Hashfunktion Hashfn. Sie verwenden es, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu erstellen, die von einer Aufzählung beschrieben wird, mit der angegebenen Reihenfolge-Prädikat- und Hashfunktion.

Beispiel

// cliext_hash_multiset_construct.cpp
// compile with: /clr
#include <cliext/hash_set>

int myfun(wchar_t key)
    { // hash a key
    return (key ^ 0xdeadbeef);
    }

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
// construct an empty container
    Myhash_multiset c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule
    Myhash_multiset c2 = cliext::greater_equal<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    c2.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule and hash function
    Myhash_multiset c2h(cliext::greater_equal<wchar_t>(),
        gcnew Myhash_multiset::hasher(&myfun));
    System::Console::WriteLine("size() = {0}", c2h.size());

    c2h.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an iterator range
    Myhash_multiset c3(c1.begin(), c1.end());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule
    Myhash_multiset c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule and hash function
    Myhash_multiset c4h(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>(),
        gcnew Myhash_multiset::hasher(&myfun));
    for each (wchar_t elem in c4h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an enumeration
    Myhash_multiset c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule
    Myhash_multiset c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
            cliext::greater_equal<wchar_t>());
    for each (wchar_t elem in c6)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule and hash function
    Myhash_multiset c6h(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3,
            cliext::greater_equal<wchar_t>(),
                gcnew Myhash_multiset::hasher(&myfun));
    for each (wchar_t elem in c6h)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct from a generic container
    Myhash_multiset c7(c4);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    Myhash_multiset c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
a b c
size() = 0
a b c
size() = 0
c b a

a b c
a b c
c b a

a b c
a b c
c b a

a b c
a b c

hash_multiset::hasher (STL/CLR)

Der Hashingstellvertretung für einen Schlüssel.

Syntax

Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
    hasher;

Hinweise

Der Typ beschreibt einen Stellvertretung, der einen Schlüsselwert in eine ganze Zahl konvertiert.

Beispiel

// cliext_hash_multiset_hasher.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }

hash(L'a') = 1616896120
hash(L'b') = 570892832

hash_multiset::insert (STL/CLR)

Fügt Elemente hinzu.

Syntax

iterator insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
    void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);

Parameter

first
Anfang des zu einfügenden Bereichs.

last
Ende des zu einfügenden Bereichs.

right
Aufzählung, die eingefügt werden soll.

Val
Schlüsselwert, der eingefügt werden soll.

where
Wo im Container eingefügt werden soll (nur Hinweis).

Hinweise

Jede der Memberfunktionen fügt eine Sequenz ein, die von den verbleibenden Operanden angegeben wird.

Die erste Memberfunktion fügt ein Element mit Wertwert val ein und gibt einen Iterator zurück, der das neu eingefügte Element angibt. Sie verwenden es, um ein einzelnes Element einzufügen.

Die zweite Memberfunktion fügt ein Element mit Wertwert val ein , wobei als Hinweis (zur Verbesserung der Leistung) ein Element eingefügt wird und ein Iterator zurückgegeben wird, der das neu eingefügte Element angibt. Sie verwenden es, um ein einzelnes Element einzufügen, das möglicherweise neben einem element liegt, das Sie kennen.

Die dritte Memberfunktion fügt die Sequenz [first, last). Sie verwenden es, um null oder mehr Elemente aus einer anderen Sequenz einzufügen.

Die vierte Memberfunktion fügt die Sequenz ein, die von der rechten Seite festgelegt ist. Sie verwenden es, um eine Sequenz einzufügen, die von einem Aufzählerator beschrieben wird.

Jede Elementeinfügeung dauert zeit proportional zum Logarithmus der Anzahl der Elemente in der kontrollierten Sequenz. Die Einfügezeit kann jedoch in amortisierten Konstantenzeit auftreten, wenn ein Hinweis angegeben wird, das ein Element an der Einfügemarke angibt.

Beispiel

// cliext_hash_multiset_insert.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value, unique and duplicate
    System::Console::WriteLine("insert(L'x') = {0}",
        *c1.insert(L'x'));

    System::Console::WriteLine("insert(L'b') = {0}",
        *c1.insert(L'b'));

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value with hint
    System::Console::WriteLine("insert(begin(), L'y') = {0}",
        *c1.insert(c1.begin(), L'y'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an iterator range
    Myhash_multiset c2;
    Myhash_multiset::iterator it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an enumeration
    Myhash_multiset c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(L'x') = x
insert(L'b') = b
a b b c x
insert(begin(), L'y') = y
a b b c x y
a b b c x
a b b c x y

hash_multiset::iterator (STL/CLR)

Der Typ eines Iterators für die gesteuerte Sequenz.

Syntax

typedef T1 iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T1 , das als bidirektionales Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_hash_multiset_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    Myhash_multiset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_multiset::key_comp (STL/CLR)

Kopiert den Bestellstellvertretung für zwei Schlüssel.

Syntax

key_compare^key_comp();

Hinweise

Die Memberfunktion gibt den Bestellstellvertretung zurück, der zum Anordnen der kontrollierten Sequenz verwendet wird. Damit können Sie zwei Schlüssel vergleichen.

Beispiel

// cliext_hash_multiset_key_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_multiset c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

hash_multiset::key_compare (STL/CLR)

Der Bestellstellvertretung für zwei Schlüssel.

Syntax

Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
    key_compare;

Hinweise

Der Typ ist ein Synonym für den Stellvertretung, der die Reihenfolge seiner Schlüsselargumente bestimmt.

Beispiel

// cliext_hash_multiset_key_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_multiset c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

hash_multiset::key_type (STL/CLR)

Der Typ eines Sortierschlüssels.

Syntax

typedef Key key_type;

Hinweise

Der Typ ist ein Synonym für den Vorlagenparameter Key.

Beispiel

// cliext_hash_multiset_key_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" using key_type
    for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myhash_multiset::key_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_multiset::load_factor (STL/CLR)

Zählt die durchschnittliche Anzahl von Elementen pro Bucket.

Syntax

float load_factor();

Hinweise

Die Memberfunktion gibt hash_multiset::Size (STL/CLR)hash_multiset::bucket_count (STL/CLR)() /() zurück(float). Sie verwenden es, um die durchschnittliche Bucketgröße zu bestimmen.

Beispiel

// cliext_hash_multiset_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_multiset::lower_bound (STL/CLR)

Findet den Anfang des Bereichs, der einem angegebenen Schlüssel entspricht.

Syntax

iterator lower_bound(key_type key);

Parameter

key
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktion bestimmt das erste Element X in der kontrollierten Sequenz, das sich auf denselben Bucket als Schlüssel bezieht und die entsprechende Reihenfolge aufweist. Wenn kein solches Element vorhanden ist, gibt es hash_multiset::End (STL/CLR)(); andernfalls wird ein Iterator zurückgegeben, der festgelegt Xwird. Sie verwenden es, um den Anfang einer Sequenz von Elementen zu suchen, die derzeit in der kontrollierten Sequenz mit einem angegebenen Schlüssel übereinstimmen.

Beispiel

// cliext_hash_multiset_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    System::Console::WriteLine("*lower_bound(L'a') = {0}",
        *c1.lower_bound(L'a'));
    System::Console::WriteLine("*lower_bound(L'b') = {0}",
        *c1.lower_bound(L'b'));
    return (0);
    }

a b c
lower_bound(L'x')==end() = True
*lower_bound(L'a') = a
*lower_bound(L'b') = b

hash_multiset::make_value (STL/CLR)

Erstellt ein Wertobjekt.

Syntax

static value_type make_value(key_type key);

Parameter

key
Schlüsselwert, der verwendet werden soll.

Hinweise

Die Memberfunktion gibt ein value_type Objekt zurück, dessen Schlüssel schlüssel ist. Sie verwenden es, um ein Objekt zu verfassen, das für die Verwendung mit mehreren anderen Memberfunktionen geeignet ist.

Beispiel

// cliext_hash_multiset_make_value.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(Myhash_multiset::make_value(L'a'));
    c1.insert(Myhash_multiset::make_value(L'b'));
    c1.insert(Myhash_multiset::make_value(L'c'));

    // display contents " a b c"
    for each (Myhash_multiset::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_multiset::max_load_factor (STL/CLR)

Ruft die maximale Anzahl von Elementen pro Bucket ab oder legt sie fest.

Syntax

float max_load_factor();
void max_load_factor(float new_factor);

Parameter

new_factor
Neuer maximaler Ladefaktor zum Speichern.

Hinweise

Die erste Memberfunktion gibt den aktuellen gespeicherten maximalen Ladefaktor zurück. Sie verwenden es, um die maximale durchschnittliche Bucketgröße zu bestimmen.

Die zweite Memberfunktion ersetzt den speicherhöchsten Ladefaktor durch new_factor. Es tritt keine automatische Wiederverwendung auf, bis ein nachfolgendes Einfügen erfolgt.

Beispiel

// cliext_hash_multiset_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_multiset::operator= (STL/CLR)

Ersetzt die kontrollierte Sequenz.

Syntax

hash_multiset<Key>% operator=(hash_multiset<Key>% right);

Parameter

right
Der zu kopierende Container.

Hinweise

Der Memberoperator kopiert direkt im Objekt, und gibt dann zurück *this. Sie verwenden es, um die kontrollierte Sequenz durch eine Kopie der kontrollierten Sequenz rechts zu ersetzen.

Beispiel

// cliext_hash_multiset_operator_as.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c"
    for each (Myhash_multiset::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    Myhash_multiset c2;
    c2 = c1;
// display contents " a b c"
    for each (Myhash_multiset::value_type elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

hash_multiset::rbegin (STL/CLR)

Legt den Anfang der umgekehrten kontrollierten Sequenz fest.

Syntax

reverse_iterator rbegin();

Hinweise

Die Memberfunktion gibt einen Reverse-Iterator zurück, der das letzte Element der kontrollierten Sequenz oder nur außerhalb des Anfangs einer leeren Sequenz bestimmt. Demzufolge wird der beginning der umgekehrten Sequenz bestimmt. Sie können damit einen Iterator abrufen, der den current Anfang der kontrollierten Sequenz in umgekehrter Reihenfolge bestimmt; der Zustand kann sich jedoch ändern, sobald sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_hash_multiset_rbegin.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_multiset::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b

hash_multiset::reference (STL/CLR)

Der Typ eines Verweises auf ein Element.

Syntax

typedef value_type% reference;

Hinweise

Der Typ beschreibt einen Verweis auf ein Element.

Beispiel

// cliext_hash_multiset_reference.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    Myhash_multiset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myhash_multiset::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

hash_multiset::rehash (STL/CLR)

Erstellt die Hashtabelle neu.

Syntax

void rehash();

Hinweise

Die Memberfunktion erstellt die Hashtabelle neu, um sicherzustellen, dass hash_multiset::load_factor (STL/CLR)hash_multiset::max_load_factor (STL/CLR)() <=. Andernfalls erhöht sich die Hashtabelle nach der Einfügemarke nur nach Bedarf. (Es wird nie automatisch in Größe reduziert.) Sie verwenden es, um die Größe der Hashtabelle anzupassen.

Beispiel

// cliext_hash_multiset_rehash.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

a b c
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

bucket_count() = 128
load_factor() = 0.0234375
max_load_factor() = 0.25

hash_multiset::rend (STL/CLR)

Legt das Ende der umgekehrten kontrollierten Sequenz fest.

Syntax

reverse_iterator rend();

Hinweise

Die Memberfunktion gibt einen Umgekehrten Iterator zurück, der direkt über den Anfang der kontrollierten Sequenz verweist. Demzufolge wird der end der umgekehrten Sequenz bestimmt. Sie können damit einen Iterator abrufen, der das current Ende der kontrollierten Sequenz in umgekehrter Reihenfolge bestimmt; der Zustand kann sich jedoch ändern, sobald sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_hash_multiset_rend.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_multiset::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a

hash_multiset::reverse_iterator (STL/CLR)

Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz.

Syntax

typedef T3 reverse_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T3 , das als Umgekehrter Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_hash_multiset_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" reversed
    Myhash_multiset::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a

hash_multiset::size (STL/CLR)

Ermittelt die Anzahl von Elementen.

Syntax

size_type size();

Hinweise

Die Memberfunktion gibt die Länge der gesteuerten Sequenz zurück. Sie verwenden es, um die Anzahl der derzeit in der kontrollierten Sequenz befindlichen Elemente zu bestimmen. Wenn Sie sich darum kümmern, ob die Sequenz nicht zero-Größe aufweist, lesen Sie hash_multiset::leer (STL/CLR)().

Beispiel

// cliext_hash_multiset_size.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

hash_multiset::size_type (STL/CLR)

Der Typ eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int size_type;

Hinweise

Der Typ beschreibt eine nicht negative Elementanzahl.

Beispiel

// cliext_hash_multiset_size_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_multiset::size_type diff = 0;
    for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3

hash_multiset::swap (STL/CLR)

Vertauscht den Inhalt von zwei Containern.

Syntax

void swap(hash_multiset<Key>% right);

Parameter

right
Container für den Tausch von Inhalten.

Hinweise

Die Memberfunktion wechselt die kontrollierten Sequenzen zwischen this und rechts. Dies geschieht in konstanter Zeit und löst keine Ausnahmen aus. Sie verwenden es als schnelle Möglichkeit, den Inhalt von zwei Containern zu austauschen.

Beispiel

// cliext_hash_multiset_swap.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Myhash_multiset c2;
    c2.insert(L'd');
    c2.insert(L'e');
    c2.insert(L'f');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
d e f
d e f
a b c

hash_multiset::to_array (STL/CLR)

Kopiert die kontrollierte Sequenz in ein neues Array.

Syntax

cli::array<value_type>^ to_array();

Hinweise

Die Memberfunktion gibt ein Array zurück, das die kontrollierte Sequenz enthält. Sie verwenden es, um eine Kopie der kontrollierten Sequenz im Arrayformular abzurufen.

Beispiel

// cliext_hash_multiset_to_array.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

hash_multiset::upper_bound (STL/CLR)

Findet ende des Bereichs, der einem angegebenen Schlüssel entspricht.

Syntax

iterator upper_bound(key_type key);

Parameter

key
Der zu suchende Schlüsselwert.

Hinweise

Die Memberfunktion bestimmt das letzte Element X in der kontrollierten Sequenz, das sich auf denselben Bucket als Schlüssel bezieht und die entsprechende Reihenfolge für den Schlüssel aufweist. Wenn kein solches Element vorhanden ist oder wenn X es sich um das letzte Element in der kontrollierten Sequenz handelt, gibt er hash_multiset::End (STL/CLR)() zurück. Andernfalls gibt es einen Iterator zurück, der das erste Element darüber hinaus Xbestimmt. Sie verwenden es, um das Ende einer Sequenz von Elementen zu suchen, die derzeit in der kontrollierten Sequenz mit einem angegebenen Schlüssel übereinstimmen.

Beispiel

// cliext_hash_multiset_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    System::Console::WriteLine("*upper_bound(L'a') = {0}",
        *c1.upper_bound(L'a'));
    System::Console::WriteLine("*upper_bound(L'b') = {0}",
        *c1.upper_bound(L'b'));
    return (0);
    }

a b c
upper_bound(L'x')==end() = True
*upper_bound(L'a') = b
*upper_bound(L'b') = c

hash_multiset::value_comp (STL/CLR)

Kopiert den Bestellstellvertretung für zwei Elementwerte.

Syntax

value_compare^ value_comp();

Hinweise

Die Memberfunktion gibt den Bestellstellvertretung zurück, der zum Anordnen der kontrollierten Sequenz verwendet wird. Sie verwenden es, um zwei Elementwerte zu vergleichen.

Beispiel

// cliext_hash_multiset_value_comp.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

hash_multiset::value_compare (STL/CLR)

Der Bestellstellvertretung für zwei Elementwerte.

Syntax

Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
    value_compare;

Hinweise

Der Typ ist ein Synonym für den Stellvertretung, der die Reihenfolge seiner Wertargumente bestimmt.

Beispiel

// cliext_hash_multiset_value_compare.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    Myhash_multiset::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

hash_multiset::value_type (STL/CLR)

Der Typ eines Elements.

Syntax

typedef generic_value value_type;

Hinweise

Der Typ ist ein Synonym für generic_value.

Beispiel

// cliext_hash_multiset_value_type.cpp
// compile with: /clr
#include <cliext/hash_set>

typedef cliext::hash_multiset<wchar_t> Myhash_multiset;
int main()
    {
    Myhash_multiset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

    // display contents " a b c" using value_type
    for (Myhash_multiset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myhash_multiset::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c