La classe `multiset`

Article
06/16/2023

La classe multiset de la bibliothèque standard C++ est utilisée pour le stockage et la récupération des données d’une collection dans laquelle les valeurs des éléments n’ont pas besoin d’être uniques, et où ces dernières servent de valeurs de clés en fonction desquelles les données sont automatiquement triées. La valeur de clé d’un élément dans un multiset élément peut ne pas être modifiée directement. En effet, les anciennes valeurs doivent être supprimées et les éléments ayant une nouvelle valeur doivent être insérés.

Syntaxe

template <class Key, class Compare =less <Key>, class Allocator =allocator <Key>>
class multiset

Paramètres

Key
Type de données d'élément à stocker dans le multiset.

Compare
Type qui fournit un objet de fonction qui peut comparer deux valeurs d’élément en tant que clés de tri pour déterminer leur ordre relatif dans le multiset. Le prédicat binaire moins<Clé> est la valeur par défaut.

En C++14, vous pouvez activer la recherche hétérogène en spécifiant le ou std::greater<> le std::less<> prédicat qui n’a aucun paramètre de type. Pour plus d’informations, consultez recherche hétérogène dans les conteneurs associatifs .

Allocator
Type qui représente l’objet d’allocateur stocké qui encapsule des détails sur l’allocation et la désallocation de la multisetmémoire. La valeur par défaut est allocator<Key>.

Notes

La classe de bibliothèque multiset standard C++ est la suivante :

Un conteneur associatif de taille variable qui prend en charge la récupération efficace des valeurs d'éléments selon une valeur de clé associée.
Réversible, car elle fournit des itérateurs bidirectionnels pour accéder à ses éléments.
Triée, car les éléments sont classés par valeur de clé au sein du conteneur, selon une fonction de comparaison spécifiée.
Multiple dans le sens où ses éléments n’ont pas besoin d’avoir des clés uniques, afin qu’une valeur de clé puisse avoir de nombreuses valeurs d’élément associées.
Un conteneur associatif simple, car les valeurs de ses éléments sont ses valeurs de clés.
Un modèle de classe, car la fonctionnalité qu’elle fournit est générique et donc indépendante du type spécifique de données contenues en tant qu’éléments. Le type de données à utiliser est spécifié comme paramètre dans le modèle de la classe, avec la fonction de comparaison et l'allocateur.

L’itérateur fourni par la multiset classe est un itérateur bidirectionnel, mais les fonctions insert membres de classe et multiset ont des versions qui prennent comme paramètres de modèle un itérateur d’entrée plus faible, dont les exigences de fonctionnalité sont plus minimales que celles garanties par la classe d’itérateurs bidirectionnels. Les différents concepts d'itérateurs forment une famille liée par les améliorations de leurs fonctionnalités. Chaque concept d'itérateur possède son propre ensemble de spécifications, et les algorithmes qui fonctionnent avec eux doivent limiter leurs hypothèses aux spécifications fournies par ce type d'itérateur. On peut considérer qu'un itérateur d'entrée peut être déréférencé pour faire référence à un objet et qu'il peut être incrémenté à l'itérateur suivant dans la séquence. Il s’agit d’une classe avec un ensemble minimal de fonctionnalités, mais c’est suffisant pour pouvoir parler d’une plage d’itérateurs [ First, Last) dans le contexte des fonctions membres de la classe.

Le choix du type de conteneur doit être basé en général sur le type de la recherche et de l'insertion requis par l'application. Les conteneurs associatifs sont optimisés pour les opérations de recherche, d'insertion et de suppression. Les fonctions membres qui prennent explicitement en charge ces opérations sont efficaces, les faisant dans un temps qui est en moyenne proportionnel au logarithme du nombre d’éléments dans le conteneur. L’insertion d’éléments invalide aucun itérateur, et la suppression d’éléments invalide uniquement les itérateurs qui avaient pointé vers les éléments supprimés.

Il multiset doit s’agir du conteneur associatif de choix lorsque les conditions associant les valeurs à leurs clés sont remplies par l’application. Les éléments d’un multiset peut être multiple et servir de clés de tri, de sorte que les clés ne sont pas uniques. Pour ce type de structure, il peut s'agir d'une liste triée de mots qui peuvent apparaître plusieurs fois. Si les occurrences multiples de mots ne sont pas autorisées, c'est un ensemble qu'il convient d'utiliser comme structure de conteneur. Si des définitions uniques sont jointes en tant que valeurs à la liste de mots clés uniques, c'est une classe map qu'il convient d'utiliser comme structure pour la contenance des données. Si, au lieu de cela, les définitions n’étaient pas uniques, il multimap s’agirait du conteneur de choix.

Commande multiset la séquence qu’il contrôle en appelant un objet de fonction stocké de type Compare. Cet objet stocké est une fonction de comparaison accessible en appelant la fonction key_compmembre. En général, les éléments doivent être simplement moins que comparables pour établir cet ordre : pour que, compte tenu de deux éléments, il peut être déterminé qu’ils sont équivalents (dans le sens où aucun n’est inférieur à l’autre) ou qu’un élément est inférieur à l’autre. Cela entraîne le tri des éléments non équivalents. D’un point de vue plus technique, la fonction de comparaison est un prédicat binaire qui induit un ordre faible strict au sens mathématique du terme. Un prédicat binaire f(x, y) est un objet de fonction qui a deux objets d’argument x et y et une valeur de retour de true ou false. Un ordre imposé sur un ensemble est un ordre faible strict si le prédicat binaire est irréflexif, antisymétrique et transitif et si l’équivalence est transitive, où deux objets x et y sont définis pour être équivalents lorsque les deux objets f(x,y) et f(y,x) sont faux. Si la plus élevée des conditions d'égalité entre les clés remplace celle de l'équivalence, alors le tri devient total (dans le sens où tous les éléments sont classés les uns par rapport aux autres), et les clés correspondantes seront alors impossibles à différencier les unes des autres.

Constructeurs

Constructeur	Description
multiset	Construit un `multiset` vide ou une copie de l'ensemble ou d'une partie d'un `multiset` spécifié.

Typedefs

Nom de type	Description
`allocator_type`	Typedef pour la classe `allocator` de l'objet `multiset`.
`const_iterator`	Typedef pour un itérateur bidirectionnel qui peut lire un élément `const` dans le `multiset`.
`const_pointer`	Typedef pour un pointeur vers un élément `const` dans un `multiset`.
`const_reference`	Typedef pour une référence à un `const` élément stocké dans un `multiset` élément pour la lecture et l’exécution `const` d’opérations.
`const_reverse_iterator`	Typedef pour un itérateur bidirectionnel qui peut lire n'importe quel élément `const` dans le `multiset`.
`difference_type`	Typedef entier signé pour le nombre d'éléments d'un `multiset` compris dans une plage d'éléments pointés par des itérateurs.
`iterator`	Typedef pour un itérateur bidirectionnel qui permet de lire ou de modifier tout élément d'un `multiset`.
`key_compare`	Typedef pour un objet de fonction qui peut comparer deux clés pour déterminer l'ordre relatif de deux éléments d'un `multiset`.
`key_type`	Typedef pour un objet de fonction qui peut comparer deux clés de tri pour déterminer l'ordre relatif de deux éléments d'un `multiset`.
`pointer`	Typedef pour un pointeur vers un élément d'un `multiset`.
`reference`	Typedef pour une référence à un élément stocké dans un `multiset`.
`reverse_iterator`	Typedef pour un itérateur bidirectionnel qui permet de lire ou de modifier un élément d'un `multiset` inversé.
`size_type`	Type entier non signé qui peut représenter le nombre d'éléments dans un `multiset`.
`value_compare`	Typedef pour un objet de fonction qui peut comparer deux éléments en tant que clés de tri pour déterminer leur ordre relatif au sein d'un `multiset`.
`value_type`	Typedef qui décrit un objet stocké en tant qu'élément comme un `multiset` par sa capacité en tant que valeur.

Fonctions Membre

Fonction membre	Description
`begin`	Retourne un itérateur qui pointe vers le premier élément d'un `multiset`.
`cbegin`	Retourne un itérateur const qui traite le premier élément d'un `multiset`.
`cend`	Retourne un itérateur const qui traite l'emplacement situé après le dernier élément d'un `multiset`.
`clear`	Efface tous les éléments d'un `multiset`.
`contains`^C++20	Vérifiez s’il existe un élément avec la clé spécifiée dans le `multiset`.
`count`	Retourne le nombre d'éléments d'un `multiset` dont la clé correspond à celle spécifiée en tant que paramètre.
`crbegin`	Retourne un itérateur const qui traite le premier élément d'un `multiset` inversé.
`crend`	Retourne un itérateur const qui traite l'emplacement qui suit le dernier élément d'un `multiset` inversé.
`emplace`	Insère un élément construit sur place dans un `multiset`.
`emplace_hint`	Insère un élément construit sur place dans un `multiset`, avec un indicateur de positionnement.
`empty`	Vérifie si un `multiset` est vide.
`end`	Retourne un itérateur qui pointe vers l'emplacement situé après le dernier élément d'un `multiset`.
`equal_range`	Retourne une paire d'itérateurs. Le premier itérateur de la paire pointe vers le premier élément d'un `multiset` avec une clé qui est supérieure à celle spécifiée. Le deuxième itérateur de la paire pointe vers le premier élément du `multiset` avec une clé dont la valeur est supérieure ou égale à la clé spécifiée.
`erase`	Supprime d'un emplacement spécifié un élément ou une plage d'éléments compris dans un `multiset` ou supprime les éléments qui correspondent à une clé spécifiée.
`find`	Retourne un itérateur qui pointe vers le premier emplacement d'un élément d'un `multiset` dont la clé est égale à la clé spécifiée.
`get_allocator`	Retourne une copie de l'objet `allocator` qui est utilisé pour construire le `multiset`.
`insert`	Insère un élément ou une plage d'éléments dans un `multiset`.
`key_comp`	Fournit un objet de fonction qui peut comparer deux clés de tri pour déterminer l'ordre relatif de deux éléments d'un `multiset`.
`lower_bound`	Retourne un itérateur au premier élément d'un `multiset` avec une valeur de clé supérieure ou égale à celle de la clé spécifiée.
`max_size`	Retourne la longueur maximale du `multiset`.
`rbegin`	Retourne un itérateur qui pointe vers le premier élément d'un `multiset` inversé.
`rend`	Retourne un itérateur qui pointe vers l'emplacement situé après le dernier élément d'un `multiset` inversé.
`size`	Retourne le nombre d'éléments contenus dans un `multiset`.
`swap`	Échange les éléments de deux `multiset`.
`upper_bound`	Retourne un itérateur au premier élément d'un `multiset` avec une valeur de clé supérieure à celle de la clé spécifiée.
`value_comp`	Récupère une copie de l'objet de comparaison utilisé pour trier les valeurs d'éléments dans un `multiset`.

Opérateurs

Opérateur	Description
`operator=`	Remplace les éléments d'un `multiset` par une copie d'un autre `multiset`.

Spécifications

En-tête : <set>

Espace de noms : std

`multiset::allocator_type`

Type qui représente la classe d’allocator pour l’objet multiset

typedef Allocator allocator_type;

Notes

allocator_type est un synonyme du paramètre de modèle Allocator.

Pour plus d’informations sur Allocator, consultez la section Notes de la rubrique multiset, classe.

Exemple

Pour obtenir un exemple d’utilisation, consultez l’exemple get_allocatorallocator_type

`multiset::begin`

Retourne un itérateur traitant le premier élément d'un multiset.

const_iterator begin() const;

iterator begin();

Valeur de retour

Itérateur bidirectionnel ciblant le premier élément dans le multiset ou l’emplacement qui réussit un multiset vide.

Exemple

// multiset_begin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::const_iterator ms1_cIter;

   ms1.insert( 1 );
   ms1.insert( 2 );
   ms1.insert( 3 );

   ms1_Iter = ms1.begin( );
   cout << "The first element of ms1 is " << *ms1_Iter << endl;

   ms1_Iter = ms1.begin( );
   ms1.erase( ms1_Iter );

   // The following 2 lines would err as the iterator is const
   // ms1_cIter = ms1.begin( );
   // ms1.erase( ms1_cIter );

   ms1_cIter = ms1.begin( );
   cout << "The first element of ms1 is now " << *ms1_cIter << endl;
}

The first element of ms1 is 1
The first element of ms1 is now 2

`multiset::cbegin`

Retourne un itérateur const qui traite le premier élément d'une plage.

const_iterator cbegin() const;

Valeur de retour

Itérateur forward bidirectionnel const qui pointe vers le premier élément de la plage, ou vers l'emplacement situé juste après la fin d'une plage vide (pour une plage vide : cbegin() == cend()).

Notes

Avec la valeur de retour , les éléments de cbeginla plage ne peuvent pas être modifiés.

Vous pouvez utiliser cette fonction membre à la place de la fonction membre begin() afin de garantir que la valeur de retour est const_iterator. En général, elle est utilisée conjointement avec le mot clé de déduction de type auto, comme le montre l’exemple suivant. Dans cet exemple, Container est supposé être un conteneur modifiable (autre que const) de type indéfini prenant en charge begin() et cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`multiset::cend`

Retourne un itérateur const qui traite l'emplacement situé immédiatement après le dernier élément d'une plage.

const_iterator cend() const;

Valeur de retour

Itérateur forward bidirectionnel const qui pointe juste après la fin de la plage.

Notes

cend est utilisé pour vérifier si un itérateur a dépassé la fin de la plage.

Vous pouvez utiliser cette fonction membre à la place de la fonction membre end() afin de garantir que la valeur de retour est const_iterator. En général, elle est utilisée conjointement avec le mot clé de déduction de type auto, comme le montre l’exemple suivant. Dans cet exemple, Container est supposé être un conteneur modifiable (autre que const) de type indéfini prenant en charge end() et cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

La valeur retournée par cend ne doit pas être déréférencement.

`multiset::clear`

Efface tous les éléments d'un multiset.

void clear();

Exemple

// multiset_clear.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 1 );
   ms1.insert( 2 );

   cout << "The size of the multiset is initially "
        << ms1.size( ) << "." << endl;

   ms1.clear( );
   cout << "The size of the multiset after clearing is "
        << ms1.size( ) << "." << endl;
}

The size of the multiset is initially 2.
The size of the multiset after clearing is 0.

`multiset::const_iterator`

Type qui fournit un itérateur bidirectionnel capable de lire un élément const dans le multiset.

typedef implementation-defined const_iterator;

Notes

Un type const_iterator ne peut pas être utilisé pour modifier la valeur d’un élément.

Exemple

Consultez l’exemple pour begin obtenir un exemple à l’aide const_iteratorde .

`multiset::const_pointer`

Type qui fournit un pointeur vers un élément const dans un multiset.

typedef typename allocator_type::const_pointer const_pointer;

Notes

Un type const_pointer ne peut pas être utilisé pour modifier la valeur d’un élément.

Dans la plupart des cas, un itérateur doit être utilisé pour accéder aux éléments d’un multiset objet.

`multiset::const_reference`

Type qui fournit une référence à un const élément stocké dans un multiset élément pour la lecture et l’exécution const d’opérations.

typedef typename allocator_type::const_reference const_reference;

Exemple

// multiset_const_ref.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 10 );
   ms1.insert( 20 );

   // Declare and initialize a const_reference &Ref1
   // to the 1st element
   const int &Ref1 = *ms1.begin( );

   cout << "The first element in the multiset is "
        << Ref1 << "." << endl;

   // The following line would cause an error because the
   // const_reference can't be used to modify the multiset
   // Ref1 = Ref1 + 5;
}

The first element in the multiset is 10.

`multiset::const_reverse_iterator`

Type qui fournit un itérateur bidirectionnel capable de lire n'importe quel élément const dans le multiset.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Notes

Un type const_reverse_iterator ne peut pas modifier la valeur d’un élément et est utilisé pour itérer à travers l’inverse multiset .

Exemple

Consultez l’exemple pour rend obtenir un exemple de déclaration et d’utilisation du const_reverse_iteratorfichier .

`multiset::contains`

Vérifiez s’il existe un élément avec la clé spécifiée dans le multiset.

bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;

Paramètres

K
Type de la clé.

key
Valeur de clé de l’élément à rechercher.

Valeur de retour

true si l’élément est trouvé dans le conteneur ; false autrement.

Notes

contains() est nouveau en C++20. Pour l’utiliser, spécifiez l’option de compilateur /std :c++20 ou ultérieure.

template<class K> bool contains(const K& key) const participe uniquement à la résolution de surcharge si key_compare elle est transparente. Pour plus d’informations, consultez recherche hétérogène dans les conteneurs associatifs .

Exemple

// Requires /std:c++20 or /std:c++latest
#include <set>
#include <iostream>

int main()
{
    std::multiset<int> theMultiSet = {1, 2};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << theMultiSet.contains(2) << '\n';
    std::cout << theMultiSet.contains(3) << '\n';

    return 0;
}

true
false

`multiset::count`

Retourne le nombre d'éléments d'un multiset dont la clé correspond à une clé spécifiée par un paramètre.

size_type count(const Key& key) const;

Paramètres

key
Clé des éléments à mettre en correspondance à partir du multiset.

Valeur de retour

Nombre d’éléments dans la multiset clé de tri correspondant à la clé de paramètre.

Notes

La fonction membre retourne le nombre d’éléments x dans la plage

[ lower_bound(key), upper_bound(key) )

Exemple

L’exemple suivant illustre l’utilisation de la multisetfonction membre ::count.

// multiset_count.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;
    multiset<int> ms1;
    multiset<int>::size_type i;

    ms1.insert(1);
    ms1.insert(1);
    ms1.insert(2);

    // Elements don't need to be unique in multiset,
    // so duplicates are allowed and counted.
    i = ms1.count(1);
    cout << "The number of elements in ms1 with a sort key of 1 is: "
         << i << "." << endl;

    i = ms1.count(2);
    cout << "The number of elements in ms1 with a sort key of 2 is: "
         << i << "." << endl;

    i = ms1.count(3);
    cout << "The number of elements in ms1 with a sort key of 3 is: "
         << i << "." << endl;
}

The number of elements in ms1 with a sort key of 1 is: 2.
The number of elements in ms1 with a sort key of 2 is: 1.
The number of elements in ms1 with a sort key of 3 is: 0.

`multiset::crbegin`

Retourne un itérateur const qui traite le premier élément d’un multiset inversé.

const_reverse_iterator crbegin() const;

Valeur de retour

Itérateur bidirectionnel inversé const qui traite le premier élément d’un multiset inversé (ou qui traite ce qui a été le dernier élément du multiset non inversé).

Notes

crbegin est utilisé avec un multiset inversé tout comme le début est utilisé avec un multiset.

Avec la valeur de retour de crbegin, l’objet multiset ne peut pas être modifié.

Vous pouvez utiliser crbegin pour itérer un objet multiset vers l’arrière.

Exemple

// multiset_crbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::const_reverse_iterator ms1_crIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_crIter = ms1.crbegin( );
   cout << "The first element in the reversed multiset is "
        << *ms1_crIter << "." << endl;
}

The first element in the reversed multiset is 30.

`multiset::crend`

Retourne un itérateur const qui traite l’emplacement qui suit le dernier élément d’un multiset inversé.

const_reverse_iterator crend() const;

Valeur de retour

Itérateur bidirectionnel inversé const qui traite l’emplacement qui suit le dernier élément d’un multiset inversé (emplacement qui précédait celui du premier élément du multiset non inversé).

Notes

crend est utilisé avec un multiset inversé tout comme end avec un multiset.

Avec la valeur de retour de crend, l’objet multiset ne peut pas être modifié.

crend peut être utilisé pour déterminer si un itérateur inversé a atteint la fin de son objet multiset.

La valeur retournée par crend ne doit pas être déréférencement.

Exemple

// multiset_crend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   multiset <int> ms1;
   multiset <int>::const_reverse_iterator ms1_crIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_crIter = ms1.crend( ) ;
   ms1_crIter--;
   cout << "The last element in the reversed multiset is "
        << *ms1_crIter << "." << endl;
}

`multiset::difference_type`

Type entier signé qui peut être utilisé pour représenter le nombre d'éléments d'un multiset au sein d'une plage, parmi les éléments pointés par les itérateurs.

typedef typename allocator_type::difference_type difference_type;

Notes

difference_type est le type retourné durant la soustraction ou l'incrémentation via les itérateurs du conteneur. difference_type est généralement utilisé pour représenter le nombre d’éléments de la plage [ first, last) entre les itérateurs first et last. Il inclut l’élément sur lequel pointe first et la plage d’éléments allant jusqu’à l’élément (mais sans l’inclure) sur lequel pointe last.

Bien qu’il difference_type soit disponible pour tous les itérateurs qui répondent aux exigences d’un itérateur d’entrée, qui inclut la classe d’itérateurs bidirectionnels pris en charge par des conteneurs réversibles tels que set, la soustraction entre les itérateurs est prise en charge uniquement par les itérateurs à accès aléatoire fournis par un conteneur d’accès aléatoire tel que le vecteur.

Exemple

// multiset_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <set>
#include <algorithm>

int main( )
{
   using namespace std;

   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter, ms1_bIter, ms1_eIter;

   ms1.insert( 20 );
   ms1.insert( 10 );
   ms1.insert( 20 );

   ms1_bIter = ms1.begin( );
   ms1_eIter = ms1.end( );

   multiset <int>::difference_type   df_typ5, df_typ10, df_typ20;

   df_typ5 = count( ms1_bIter, ms1_eIter, 5 );
   df_typ10 = count( ms1_bIter, ms1_eIter, 10 );
   df_typ20 = count( ms1_bIter, ms1_eIter, 20 );

   // The keys, and hence the elements, of a multiset aren't unique
   cout << "The number '5' occurs " << df_typ5
        << " times in multiset ms1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in multiset ms1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in multiset ms1.\n";

   // Count the number of elements in a multiset
   multiset <int>::difference_type  df_count = 0;
   ms1_Iter = ms1.begin( );
   while ( ms1_Iter != ms1_eIter)
   {
      df_count++;
      ms1_Iter++;
   }

   cout << "The number of elements in the multiset ms1 is: "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in multiset ms1.
The number '10' occurs 1 times in multiset ms1.
The number '20' occurs 2 times in multiset ms1.
The number of elements in the multiset ms1 is: 3.

`multiset::emplace`

Insère un élément construit sur place (aucune opération de copie ni de déplacement n’est effectuée) avec un indicateur de positionnement.

template <class... Args>
iterator emplace(Args&&... args);

Paramètres

args
Arguments transférés pour construire un élément à insérer dans le multiset.

Valeur de retour

Itérateur vers l’élément qui vient d’être inséré.

Notes

Aucune référence aux éléments conteneurs n’est invalidée par cette fonction, mais elle peut invalider tous les itérateurs du conteneur.

Pendant l’emplacement, si une exception est levée, l’état du conteneur n’est pas modifié.

Exemple

// multiset_emplace.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    multiset<string> s1;

    s1.emplace("Anna");
    s1.emplace("Bob");
    s1.emplace("Carmine");

    cout << "multiset modified, now contains ";
    print(s1);
    cout << endl;

    s1.emplace("Bob");

    cout << "multiset modified, now contains ";
    print(s1);
    cout << endl;
}

`multiset::emplace_hint`

Insère un élément construit sur place (aucune opération de copie ni de déplacement n’est effectuée) avec un indicateur de positionnement.

template <class... Args>
iterator emplace_hint(
    const_iterator where,
    Args&&... args);

Paramètres

args
Arguments transférés pour construire un élément à insérer dans le multiset.

where
Emplacement où commencer à rechercher le point d'insertion correct. (Si ce point précède immédiatement where, l'insertion peut se produire dans le temps fixe amorti plutôt que dans le temps logarithmique.)

Valeur de retour

Itérateur vers l’élément qui vient d’être inséré.

Notes

Aucune référence aux éléments conteneurs n’est invalidée par cette fonction, mais elle peut invalider tous les itérateurs du conteneur.

Pendant l’emplacement, si une exception est levée, l’état du conteneur n’est pas modifié.

Pour obtenir un exemple de code, consultez set::emplace_hint.

`multiset::empty`

Vérifie si un multiset est vide.

bool empty() const;

Valeur de retour

true si la multiset valeur est vide ; false si elle multiset n’est pas vide.

Exemple

// multiset_empty.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
   using namespace std;
   multiset <int> ms1, ms2;
   ms1.insert ( 1 );

   if ( ms1.empty( ) )
      cout << "The multiset ms1 is empty." << endl;
   else
      cout << "The multiset ms1 is not empty." << endl;

   if ( ms2.empty( ) )
      cout << "The multiset ms2 is empty." << endl;
   else
      cout << "The multiset ms2 is not empty." << endl;
}

The multiset ms1 is not empty.
The multiset ms2 is empty.

`multiset::end`

Retourne l'itérateur past-the-end.

const_iterator end() const;

iterator end();

Valeur de retour

Itérateur de type past-the-end. Si le multiset est vide, multiset::end() == multiset::begin().

Notes

end est utilisé pour tester si un itérateur a réussi la fin de son multiset.

La valeur retournée par end ne doit pas être déréférencement.

Pour obtenir un exemple de code, consultez multiset::find.

`multiset::equal_range`

Retourne une paire d'itérateurs, respectivement vers le premier élément d'un objet multiset avec une clé supérieure à une clé spécifiée, et vers le premier élément d'un objet multiset avec une clé supérieure ou égale à la clé.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Paramètres

key
Clé d’argument à comparer à la clé de tri d’un élément à partir de la multiset recherche en cours.

Valeur de retour

Une paire d’itérateurs de sorte que la première est la lower_bound clé et que la seconde est la upper_bound clé.

Pour accéder au premier itérateur d’une paire pr retournée par la fonction membre, utilisez pr. first, et pour déréférencer l’itérateur lié inférieur, utilisez *( pr. first). Pour accéder au deuxième itérateur d’une paire pr retournée par la fonction membre, utilisez pr. second, et pour déréférencer l’itérateur de limite supérieure, utilisez *( pr. second).

Exemple

// multiset_equal_range.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   typedef multiset<int, less<int> > IntSet;
   IntSet ms1;
   multiset <int> :: const_iterator ms1_RcIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   pair <IntSet::const_iterator, IntSet::const_iterator> p1, p2;
   p1 = ms1.equal_range( 20 );

   cout << "The upper bound of the element with "
        << "a key of 20 in the multiset ms1 is: "
        << *( p1.second ) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20 in the multiset ms1 is: "
        << *( p1.first ) << "." << endl;

   // Compare the upper_bound called directly
   ms1_RcIter = ms1.upper_bound( 20 );
   cout << "A direct call of upper_bound( 20 ) gives "
        << *ms1_RcIter << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 20 )." << endl;

   p2 = ms1.equal_range( 40 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == ms1.end( ) ) && ( p2.second == ms1.end( ) ) )
      cout << "The multiset ms1 doesn't have an element "
              << "with a key less than 40." << endl;
   else
      cout << "The element of multiset ms1 with a key >= 40 is: "
                << *( p1.first ) << "." << endl;
}

The upper bound of the element with a key of 20 in the multiset ms1 is: 30.
The lower bound of the element with a key of 20 in the multiset ms1 is: 20.
A direct call of upper_bound( 20 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 20 ).
The multiset ms1 doesn't have an element with a key less than 40.

`multiset::erase`

Supprime d'un emplacement spécifié un élément ou une plage d'éléments compris dans un multiset ou supprime les éléments qui correspondent à une clé spécifiée.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Paramètres

Where
Position de l’élément à supprimer.

First
Position du premier élément à supprimer.

Last
Position juste après le dernier élément à supprimer.

key
Valeur de clé des éléments à supprimer.

Valeur de retour

Pour les deux premières fonctions membres, itérateur bidirectionnel qui désigne le premier élément restant au-delà des éléments supprimés, ou un élément qui est la fin du multiset cas où aucun élément de ce type n’existe.

Pour la troisième fonction membre, retourne le nombre d’éléments qui ont été supprimés du multiset.

Notes

Pour obtenir un exemple de code, consultez set::erase.

`multiset::find`

Retourne un itérateur qui fait référence à l’emplacement d’un élément dans un multiset qui a une clé équivalente à une clé spécifiée.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Paramètres

key
Valeur de clé à mettre en correspondance par la clé de tri d’un élément à partir de la multiset recherche en cours.

Valeur de retour

Itérateur qui fait référence à l’emplacement d’un élément avec une clé spécifiée ou à l’emplacement qui réussit le dernier élément dans le multiset ( multiset::end()) si aucune correspondance n’est trouvée pour la clé.

Notes

La fonction membre retourne un itérateur qui fait référence à un élément dans la clé dont la multiset clé équivaut à l’argument key sous un prédicat binaire qui induise un classement basé sur une relation inférieure à celle de la milliseconde.

Si la valeur de retour d’un find objet est affectée à un const_iterator, l’objet multiset ne peut pas être modifié. Si la valeur de retour d’un find objet est affectée à un iterator, l’objet multiset peut être modifié

Exemple

// compile with: /EHsc /W4 /MTd
#include <set>
#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    multiset<int> s1({ 40, 45 });
    cout << "The starting multiset s1 is: " << endl;
    print_collection(s1);

    vector<int> v;
    v.push_back(43);
    v.push_back(41);
    v.push_back(46);
    v.push_back(42);
    v.push_back(44);
    v.push_back(44); // attempt a duplicate

    cout << "Inserting the following vector data into s1: " << endl;
    print_collection(v);

    s1.insert(v.begin(), v.end());

    cout << "The modified multiset s1 is: " << endl;
    print_collection(s1);
    cout << endl;
    findit(s1, 45);
    findit(s1, 6);
}

`multiset::get_allocator`

Retourne une copie de l’objet allocator utilisé pour construire le multiset.

allocator_type get_allocator() const;

Valeur de retour

Allocator utilisé par le multiset.

Notes

Les allocateurs de la multiset classe spécifient la façon dont la classe gère le stockage. Les allocateurs par défaut fournis avec les classes de conteneur de bibliothèque C++ Standard suffisent à satisfaire la plupart des besoins en programmation. L'écriture et l'utilisation de votre propre classe d'allocateur font l'objet d'une rubrique avancée du langage C++.

Exemple

// multiset_get_allocator.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int>::allocator_type ms1_Alloc;
   multiset <int>::allocator_type ms2_Alloc;
   multiset <double>::allocator_type ms3_Alloc;
   multiset <int>::allocator_type ms4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   multiset <int> ms1;
   multiset <int, allocator<int> > ms2;
   multiset <double, allocator<double> > ms3;

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << ms2.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << ms3.max_size( ) <<  "." << endl;

   // The following lines create a multiset ms4
   // with the allocator of multiset ms1
   ms1_Alloc = ms1.get_allocator( );
   multiset <int> ms4( less<int>( ), ms1_Alloc );
   ms4_Alloc = ms4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated with the other
   if( ms1_Alloc == ms4_Alloc )
   {
      cout << "Allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "Allocators are not interchangeable."
           << endl;
   }
}

`multiset::insert`

Insère un élément ou une plage d'éléments dans un multiset.

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

// (5) range
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

Paramètres

Val
Valeur d’un élément à insérer dans le multiset.

Where
Emplacement où commencer à rechercher le point d'insertion correct. (Si ce point précède immédiatement Where, l'insertion peut se produire dans le temps fixe amorti plutôt que dans le temps logarithmique.)

ValTy
Paramètre de modèle qui spécifie le type d’argument que l’argument multiset peut utiliser pour construire un élément de value_type, et des forwards parfaits Val en tant qu’argument.

First
Position du premier élément à copier.

Last
Position juste au-delà du dernier élément à copier.

1
Argument de fonction de modèle qui répond aux exigences d’un input_iterator_tag élément pointant vers des éléments d’un type qui peuvent être utilisés pour construire 1 objets.

IList
initializer_list À partir duquel copier les éléments.

Valeur de retour

Les fonctions membres à insertion à un élément, (1) et (2), retournent un itérateur à la position où le nouvel élément a été inséré dans le multiset.

Les fonctions membres single-element-with-hint, (3) et (4), retournent un itérateur qui pointe vers la position où le nouvel élément a été inséré dans le multiset.

Notes

Aucun pointeur ou référence n'est invalidé par cette fonction, mais elle peut invalider tous les itérateurs du conteneur.

Pendant l’insertion d’un seul élément, si une exception est levée, l’état du conteneur n’est pas modifié. Durant l'insertion de plusieurs éléments, si une exception est levée, le conteneur reste dans un état non spécifié mais valide.

Un value_type conteneur est un typedef qui appartient au conteneur et, pour set, multiset<V>::value_type est de type const V.

La fonction membre de plage (5) insère la séquence de valeurs d’élément dans un multiset élément qui correspond à chaque élément traité par un itérateur dans la plage [First, Last); par conséquent, Last il n’est pas inséré. La fonction membre de conteneur end() fait référence à la position qui suit le dernier élément du conteneur. Par exemple, l'instruction s.insert(v.begin(), v.end()); insère tous les éléments de v dans s.

La fonction membre de liste d’initialiseurs (6) utilise un initializer_list pour copier des éléments dans le multiset.

Pour l’insertion d’un élément construit en place, autrement dit, aucune opération de copie ou de déplacement n’est effectuée, consultez multiset::emplace et multiset::emplace_hint.

Exemple

// multiset_insert.cpp
// compile with: /EHsc
#include <set>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    // insert single values
    multiset<int> s1;
    // call insert(const value_type&) version
    s1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    s1.insert(20);

    cout << "The original multiset values of s1 are:" << endl;
    print(s1);

    // intentionally attempt a duplicate, single element
    s1.insert(1);
    cout << "The modified multiset values of s1 are:" << endl;
    print(s1);
    cout << endl;

    // single element, with hint
    s1.insert(s1.end(), 30);
    cout << "The modified multiset values of s1 are:" << endl;
    print(s1);
    cout << endl;

    // The templatized version inserting a jumbled range
    multiset<int> s2;
    vector<int> v;
    v.push_back(43);
    v.push_back(294);
    v.push_back(41);
    v.push_back(330);
    v.push_back(42);
    v.push_back(45);

    cout << "Inserting the following vector data into s2:" << endl;
    print(v);

    s2.insert(v.begin(), v.end());

    cout << "The modified multiset values of s2 are:" << endl;
    print(s2);
    cout << endl;

    // The templatized versions move-constructing elements
    multiset<string>  s3;
    string str1("blue"), str2("green");

    // single element
    s3.insert(move(str1));
    cout << "After the first move insertion, s3 contains:" << endl;
    print(s3);

    // single element with hint
    s3.insert(s3.end(), move(str2));
    cout << "After the second move insertion, s3 contains:" << endl;
    print(s3);
    cout << endl;

    multiset<int> s4;
    // Insert the elements from an initializer_list
    s4.insert({ 4, 44, 2, 22, 3, 33, 1, 11, 5, 55 });
    cout << "After initializer_list insertion, s4 contains:" << endl;
    print(s4);
    cout << endl;
}

`multiset::iterator`

Type qui fournit un itérateur bidirectionnel constant qui peut lire n’importe quel élément dans un multiset.

typedef implementation-defined iterator;

Exemple

Consultez l’exemple de début pour obtenir un exemple de déclaration et d’utilisation d’un iterator.

`multiset::key_comp`

Récupère une copie de l'objet de comparaison utilisé pour trier les clés au sein d'un multiset.

key_compare key_comp() const;

Valeur de retour

Retourne l’objet de fonction qu’un multiset utilise pour classer ses éléments, qui est le paramètre Comparede modèle .

Pour plus d’informations sur Compare, consultez la section Notes de la rubrique multiset, classe.

Notes

L’objet stocké définit la fonction membre :

opérateur bool( const Key&x, const Key&y) ;

qui retourne true si x précède strictement y dans l’ordre de tri.

Les deux key_compare sont value_compare des synonymes pour le paramètre Comparede modèle. Les deux types sont fournis pour le jeu de classes et le multiset, où ils sont identiques, pour la compatibilité avec les classes map et multimap, où ils sont distincts.

Exemple

// multiset_key_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   multiset <int, less<int> > ms1;
   multiset <int, less<int> >::key_compare kc1 = ms1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of s1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of ms1."
           << endl;
   }

   multiset <int, greater<int> > ms2;
   multiset <int, greater<int> >::key_compare kc2 = ms2.key_comp( ) ;
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of ms2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of ms2."
           << endl;
   }
}

kc1( 2,3 ) returns value of true, where kc1 is the function object of s1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of ms2.

`multiset::key_compare`

Type qui fournit un objet de fonction pouvant comparer deux clés de tri pour déterminer l'ordre relatif de deux éléments au sein d'un multiset.

typedef Compare key_compare;

Notes

key_compare est un synonyme du paramètre de modèle Compare.

Pour plus d’informations sur Compare, consultez la section Remarques de la multiset rubrique Classe .

Exemple

Consultez l’exemple pour key_comp obtenir un exemple de déclaration et d’utilisation key_compare.

`multiset::key_type`

Type qui fournit un objet de fonction qui peut comparer des clés de tri pour déterminer l’ordre relatif de deux éléments dans le multiset.

typedef Key key_type;

Notes

key_type est un synonyme du paramètre de modèle Key.

Pour plus d’informations sur Key, consultez la section Remarques de la multiset rubrique Classe .

Exemple

Consultez l’exemple pour value_type obtenir un exemple de déclaration et d’utilisation key_type.

`multiset::lower_bound`

Retourne un itérateur au premier élément d'un multiset avec une valeur de clé supérieure ou égale à celle de la clé spécifiée.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Paramètres

key
Clé d’argument à comparer à la clé de tri d’un élément à partir de la multiset recherche en cours.

Valeur de retour

const_iterator Ou iterator qui traite l’emplacement d’un élément dans un multiset élément avec une clé égale ou supérieure à la clé d’argument, ou qui traite l’emplacement qui réussit le dernier élément dans le multiset cas où aucune correspondance n’est trouvée pour la clé.

Exemple

// multiset_lower_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: const_iterator ms1_AcIter, ms1_RcIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_RcIter = ms1.lower_bound( 20 );
   cout << "The element of multiset ms1 with a key of 20 is: "
        << *ms1_RcIter << "." << endl;

   ms1_RcIter = ms1.lower_bound( 40 );

   // If no match is found for the key, end( ) is returned
   if ( ms1_RcIter == ms1.end( ) )
      cout << "The multiset ms1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of multiset ms1 with a key of 40 is: "
           << *ms1_RcIter << "." << endl;

   // The element at a specific location in the multiset can be
   // found using a dereferenced iterator addressing the location
   ms1_AcIter = ms1.end( );
   ms1_AcIter--;
   ms1_RcIter = ms1.lower_bound( *ms1_AcIter );
   cout << "The element of ms1 with a key matching "
        << "that of the last element is: "
        << *ms1_RcIter << "." << endl;
}

The element of multiset ms1 with a key of 20 is: 20.
The multiset ms1 doesn't have an element with a key of 40.
The element of ms1 with a key matching that of the last element is: 30.

`multiset::max_size`

Retourne la longueur maximale du multiset.

size_type max_size() const;

Valeur de retour

Longueur maximale possible du multiset.

Exemple

// multiset_max_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::size_type i;

   i = ms1.max_size( );
   cout << "The maximum possible length "
        << "of the multiset is " << i << "." << endl;
}

`multiset::multiset`

Construit un multiset vide ou une copie de l'ensemble ou d'une partie d'un autre multiset.

multiset();

explicit multiset (
    const Compare& Comp);

multiset (
    const Compare& Comp,
    const Allocator& Al);

multiset(
    const multiset& Right);

multiset(
    multiset&& Right);

multiset(
    initializer_list<Type> IList);

multiset(
    initializer_list<Type> IList,
    const Compare& Comp);

multiset(
    initializer_list<Type> IList,
    const Compare& Comp,
    const Allocator& Al);

template <class InputIterator>
multiset (
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
multiset (
    InputIterator First,
    InputIterator Last,
    const Compare& Comp);

template <class InputIterator>
multiset (
    InputIterator First,
    InputIterator Last,
    const Compare& Comp,
    const Allocator& Al);

Paramètres

Al
Classe d’allocateur de stockage à utiliser pour cet objet multiset, qui est par défaut Allocator.

Comp
Fonction de comparaison de type const Compare utilisée pour ordonner les éléments dans le multiset (par défaut, Compare).

Right
multiset dont le multiset construit doit être une copie.

First
Position du premier élément de la plage d'éléments à copier.

Last
Position du premier élément au-delà de la plage d'éléments à copier.

IList
initializer_list À partir duquel copier les éléments.

Notes

Tous les constructeurs stockent un type d’objet allocator qui gère le stockage de mémoire pour le multiset et qui peut être retourné ultérieurement en appelant get_allocator. Le paramètre d’allocateur est souvent omis dans les déclarations de classe, et des macros de prétraitement sont utilisées pour substituer des allocateurs de remplacement.

Tous les constructeurs initialisent leur multiset.

Tous les constructeurs stockent un objet de fonction de type Compare utilisé pour établir un ordre entre les clés du multiset et qui peuvent être retournés ultérieurement en appelant key_comp.

Les trois premiers constructeurs spécifient un multiset initial vide, le second spécifiant le type de fonction de comparaison (Comp) à utiliser pour établir l’ordre des éléments et le troisième spécifiant explicitement le type d’allocateur (Al) à utiliser. Le mot clé explicit supprime certains genres de conversions de type automatiques.

Le quatrième constructeur spécifie une copie du multiset Right.

Le cinquième constructeur spécifie une copie de l’objet multiset en déplaçant Right.

Les constructeurs 6e, 7 et 8e spécifient une initializer_list à partir de laquelle copier les éléments.

Les trois constructeurs suivants copient la plage [First, Last) d’un multiset avec une précision croissante en spécifiant le type de fonction de comparaison et l’allocateur.

Exemple

// multiset_ctor.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;
    //multiset <int>::iterator ms1_Iter, ms2_Iter, ms3_Iter;
    multiset <int>::iterator ms4_Iter, ms5_Iter, ms6_Iter, ms7_Iter;

    // Create an empty multiset ms0 of key type integer
    multiset <int> ms0;

    // Create an empty multiset ms1 with the key comparison
    // function of less than, then insert 4 elements
    multiset <int, less<int> > ms1;
    ms1.insert(10);
    ms1.insert(20);
    ms1.insert(20);
    ms1.insert(40);

    // Create an empty multiset ms2 with the key comparison
    // function of greater than, then insert 2 elements
    multiset <int, less<int> > ms2;
    ms2.insert(10);
    ms2.insert(20);

    // Create a multiset ms3 with the
    // allocator of multiset ms1
    multiset <int>::allocator_type ms1_Alloc;
    ms1_Alloc = ms1.get_allocator();
    multiset <int> ms3(less<int>(), ms1_Alloc);
    ms3.insert(30);

    // Create a copy, multiset ms4, of multiset ms1
    multiset <int> ms4(ms1);

    // Create a multiset ms5 by copying the range ms1[ first,  last)
    multiset <int>::const_iterator ms1_bcIter, ms1_ecIter;
    ms1_bcIter = ms1.begin();
    ms1_ecIter = ms1.begin();
    ms1_ecIter++;
    ms1_ecIter++;
    multiset <int> ms5(ms1_bcIter, ms1_ecIter);

    // Create a multiset ms6 by copying the range ms4[ first,  last)
    // and with the allocator of multiset ms2
    multiset <int>::allocator_type ms2_Alloc;
    ms2_Alloc = ms2.get_allocator();
    multiset <int> ms6(ms4.begin(), ++ms4.begin(), less<int>(), ms2_Alloc);

    cout << "ms1 =";
    for (auto i : ms1)
        cout << " " << i;
    cout << endl;

    cout << "ms2 =";
    for (auto i : ms2)
        cout << " " << i;
   cout << endl;

   cout << "ms3 =";
   for (auto i : ms3)
       cout << " " << i;
    cout << endl;

    cout << "ms4 =";
    for (auto i : ms4)
        cout << " " << i;
    cout << endl;

    cout << "ms5 =";
    for (auto i : ms5)
        cout << " " << i;
    cout << endl;

    cout << "ms6 =";
    for (auto i : ms6)
        cout << " " << i;
    cout << endl;

    // Create a multiset by moving ms5
    multiset<int> ms7(move(ms5));
    cout << "ms7 =";
    for (auto i : ms7)
        cout << " " << i;
    cout << endl;

    // Create a multiset with an initializer_list
    multiset<int> ms8({1, 2, 3, 4});
    cout << "ms8=";
    for (auto i : ms8)
        cout << " " << i;
    cout << endl;
}

`multiset::operator=`

Remplace les éléments de ce multiset par les éléments d’un autre multiset.

multiset& operator=(const multiset& right);

multiset& operator=(multiset&& right);

Paramètres

Right
multiset à partir duquel les éléments sont copiés ou déplacés.

Notes

operator= copie ou déplace les éléments de Right dans ce multiset, en fonction du type de référence (lvalue ou rvalue) utilisé. Les éléments qui figurent dans ce multiset avant l’exécution de operator= sont ignorés.

Exemple

// multiset_operator_as.cpp
// compile with: /EHsc
#include <multiset>
#include <iostream>

int main( )
   {
   using namespace std;
   multiset<int> v1, v2, v3;
   multiset<int>::iterator iter;

   v1.insert(10);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << *iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;
   }

`multiset::pointer`

Type qui fournit un pointeur vers un élément d'un objet multiset.

typedef typename allocator_type::pointer pointer;

Notes

Un type pointer peut être utilisé pour modifier la valeur d’un élément.

Dans la plupart des cas, un itérateur doit être utilisé pour accéder aux éléments d’un multiset objet.

`multiset::rbegin`

Retourne un itérateur ciblant le premier élément d’un multiset inversé.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valeur de retour

Itérateur bidirectionnel inverse ciblant le premier élément d’un élément inversé multiset ou traitant ce qui avait été le dernier élément de l’inversion multiset.

Notes

rbegin est utilisé avec un rbegin inversé multiset comme rbegin est utilisé avec un multiset.

Si la valeur de retour d’un rbegin objet est affectée à un const_reverse_iterator, l’objet multiset ne peut pas être modifié. Si la valeur de retour d’un rbegin objet est affectée à un reverse_iterator, l’objet multiset peut être modifié.

Vous pouvez utiliser rbegin pour itérer un objet multiset vers l’arrière.

Exemple

// multiset_rbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::reverse_iterator ms1_rIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_rIter = ms1.rbegin( );
   cout << "The first element in the reversed multiset is "
        << *ms1_rIter << "." << endl;

   // begin can be used to start an iteration
   // through a multiset in a forward order
   cout << "The multiset is:";
   for ( ms1_Iter = ms1.begin( ) ; ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << endl;

   // rbegin can be used to start an iteration
   // through a multiset in a reverse order
   cout << "The reversed multiset is:";
   for ( ms1_rIter = ms1.rbegin( ) ; ms1_rIter != ms1.rend( ); ms1_rIter++ )
      cout << " " << *ms1_rIter;
   cout << endl;

   // a multiset element can be erased by dereferencing to its key
   ms1_rIter = ms1.rbegin( );
   ms1.erase ( *ms1_rIter );

   ms1_rIter = ms1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed multiset is "<< *ms1_rIter << "."
        << endl;
}

The first element in the reversed multiset is 30.
The multiset is: 10 20 30
The reversed multiset is: 30 20 10
After the erasure, the first element in the reversed multiset is 20.

`multiset::reference`

Type qui fournit une référence à un élément stocké dans un multiset.

typedef typename allocator_type::reference reference;

Exemple

// multiset_ref.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 10 );
   ms1.insert( 20 );

   // Declare and initialize a reference &Ref1 to the 1st element
   const int &Ref1 = *ms1.begin( );

   cout << "The first element in the multiset is "
        << Ref1 << "." << endl;
}

The first element in the multiset is 10.

`multiset::rend`

Retourne un itérateur qui traite l'emplacement suivant le dernier élément d'un multiset inversé.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valeur de retour

Itérateur bidirectionnel inverse qui traite l’emplacement qui réussit le dernier élément d’un inverse (emplacement qui avait précédé le premier élément dans l’élément non multisetinversé multiset ).

Notes

rend est utilisé avec un multiset inversé tout comme end avec un multiset.

Si la valeur de retour d’un rend objet est affectée à un const_reverse_iterator, l’objet multiset ne peut pas être modifié. Si la valeur de retour d’un rend objet est affectée à un reverse_iterator, l’objet multiset peut être modifié.

Vous pouvez utiliser rend pour déterminer si un itérateur inversé a atteint la fin de son multiset.

La valeur retournée par rend ne doit pas être déréférencement.

Exemple

// multiset_rend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::reverse_iterator ms1_rIter;
   multiset <int>::const_reverse_iterator ms1_crIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_rIter = ms1.rend( ) ;
   ms1_rIter--;
   cout << "The last element in the reversed multiset is "
        << *ms1_rIter << "." << endl;

   // end can be used to terminate an iteration
   // through a multiset in a forward order
   cout << "The multiset is: ";
   for ( ms1_Iter = ms1.begin( ) ; ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << *ms1_Iter << " ";
   cout << "." << endl;

   // rend can be used to terminate an iteration
   // through a multiset in a reverse order
   cout << "The reversed multiset is: ";
   for ( ms1_rIter = ms1.rbegin( ) ; ms1_rIter != ms1.rend( ); ms1_rIter++ )
      cout << *ms1_rIter << " ";
   cout << "." << endl;

   ms1_rIter = ms1.rend( );
   ms1_rIter--;
   ms1.erase ( *ms1_rIter );

   ms1_rIter = ms1.rend( );
   --ms1_rIter;
   cout << "After the erasure, the last element in the "
        << "reversed multiset is " << *ms1_rIter << "." << endl;
}

`multiset::reverse_iterator`

Type qui fournit un itérateur bidirectionnel capable de lire ou de modifier un élément d’un multiset inversé.

typedef std::reverse_iterator<iterator> reverse_iterator;

Notes

Un type reverse_iterator est utilisé pour itérer à travers l’inverse multiset .

Exemple

Consultez l’exemple pour rbegin obtenir un exemple de déclaration et d’utilisation reverse_iterator.

`multiset::size`

Retourne le nombre d'éléments d'un multiset.

size_type size() const;

Valeur de retour

Longueur actuelle du multiset.

Exemple

// multiset_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: size_type i;

   ms1.insert( 1 );
   i = ms1.size( );
   cout << "The multiset length is " << i << "." << endl;

   ms1.insert( 2 );
   i = ms1.size( );
   cout << "The multiset length is now " << i << "." << endl;
}

The multiset length is 1.
The multiset length is now 2.

`multiset::size_type`

Type entier non signé qui peut représenter le nombre d'éléments dans un multiset.

typedef typename allocator_type::size_type size_type;

Exemple

Voir un exemple pour size obtenir un exemple de déclaration et d’utilisation size_type

`multiset::swap`

Échange les éléments de deux multisets.

void swap(
    multiset<Key, Compare, Allocator>& right);

Paramètres

Right
Argument multiset qui fournit les éléments à échanger avec le multiset cible.

Notes

La fonction membre n’invalide aucun pointeur, itérateur ou référence qui désigne des éléments dans les deux multisets dont les éléments sont échangés.

Exemple

// multiset_swap.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1, ms2, ms3;
   multiset <int>::iterator ms1_Iter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );
   ms2.insert( 100 );
   ms2.insert( 200 );
   ms3.insert( 300 );

   cout << "The original multiset ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;

   // This is the member function version of swap
   ms1.swap( ms2 );

   cout << "After swapping with ms2, list ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;

   // This is the specialized template version of swap
   swap( ms1, ms3 );

   cout << "After swapping with ms3, list ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout   << "." << endl;
}

The original multiset ms1 is: 10 20 30.
After swapping with ms2, list ms1 is: 100 200.
After swapping with ms3, list ms1 is: 300.

`multiset::upper_bound`

Retourne un itérateur au premier élément d'un multiset avec une valeur de clé supérieure à celle de la clé spécifiée.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Paramètres

key
Clé d’argument à comparer à la clé de tri d’un élément à partir de la multiset recherche en cours.

Valeur de retour

Itérateur ou qui traite l’emplacement d’un élément dans une multiset clé supérieure à la clé d’argument, ou qui traite l’emplacement qui réussit le dernier élément dans le multiset cas où aucune correspondance n’est trouvée pour la clé.const_iterator

Exemple

// multiset_upper_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: const_iterator ms1_AcIter, ms1_RcIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_RcIter = ms1.upper_bound( 20 );
   cout << "The first element of multiset ms1 with a key greater "
           << "than 20 is: " << *ms1_RcIter << "." << endl;

   ms1_RcIter = ms1.upper_bound( 30 );

   // If no match is found for the key, end( ) is returned
   if ( ms1_RcIter == ms1.end( ) )
      cout << "The multiset ms1 doesn't have an element "
              << "with a key greater than 30." << endl;
   else
      cout << "The element of multiset ms1 with a key > 40 is: "
           << *ms1_RcIter << "." << endl;

   // The element at a specific location in the multiset can be
   // found using a dereferenced iterator addressing the location
   ms1_AcIter = ms1.begin( );
   ms1_RcIter = ms1.upper_bound( *ms1_AcIter );
   cout << "The first element of ms1 with a key greater than"
        << endl << "that of the initial element of ms1 is: "
        << *ms1_RcIter << "." << endl;
}

The first element of multiset ms1 with a key greater than 20 is: 30.
The multiset ms1 doesn't have an element with a key greater than 30.
The first element of ms1 with a key greater than
that of the initial element of ms1 is: 20.

`multiset::value_comp`

Récupère une copie de l'objet de comparaison utilisé pour ordonner les valeurs des éléments d'un objet multiset.

value_compare value_comp() const;

Valeur de retour

Retourne l’objet de fonction qu’un multiset utilise pour classer ses éléments, qui est le paramètre Comparede modèle .

Pour plus d’informations sur Compare, consultez la section Remarques de la multiset rubrique Classe .

Notes

L’objet stocké définit la fonction membre :

bool operator( const Key&_xVal, const Key&_yVal);

qui retourne true si _xVal précède et n’est pas égal à _yVal dans l’ordre de tri.

Les deux key_compare sont value_compare des synonymes pour le paramètre Comparede modèle. Les deux types sont fournis pour les classes définies et multiset, où elles sont identiques, pour la compatibilité avec les classes map et multimap, où elles sont distinctes.

Exemple

// multiset_value_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   multiset <int, less<int> > ms1;
   multiset <int, less<int> >::value_compare vc1 = ms1.value_comp( );
   bool result1 = vc1( 2, 3 );
   if( result1 == true )
   {
      cout << "vc1( 2,3 ) returns value of true, "
           << "where vc1 is the function object of ms1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of ms1."
           << endl;
   }

   set <int, greater<int> > ms2;
   set<int, greater<int> >::value_compare vc2 = ms2.value_comp( );
   bool result2 = vc2( 2, 3 );
   if( result2 == true )
   {
      cout << "vc2( 2,3 ) returns value of true, "
           << "where vc2 is the function object of ms2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of ms2."
           << endl;
   }
}

vc1( 2,3 ) returns value of true, where vc1 is the function object of ms1.
vc2( 2,3 ) returns value of false, where vc2 is the function object of ms2.

`multiset::value_compare`

Type qui fournit un objet de fonction qui peut comparer deux clés de tri pour déterminer leur ordre relatif dans le multiset.

typedef key_compare value_compare;

Notes

value_compare est un synonyme du paramètre de modèle Compare.

Pour plus d’informations sur Compare, consultez la section Notes de la rubrique multiset, classe.

Exemple

Consultez l’exemple pour value_comp obtenir un exemple de déclaration et d’utilisation value_compare.

`multiset::value_type`

Type qui décrit un objet stocké en tant qu’élément comme une multiset valeur dans sa capacité.

typedef Key value_type;

Notes

value_type est un synonyme du paramètre de modèle Key.

Les deux key_type sont value_type des synonymes pour le paramètre Keyde modèle. Les deux types sont fournis pour le jeu de classes et le multiset, où ils sont identiques, pour la compatibilité avec les classes map et multimap, où ils sont distincts.

Pour plus d’informations sur Key, consultez la section Notes de la rubrique.

Exemple

// multiset_value_type.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;

   multiset <int> :: value_type svt_Int;   // Declare value_type
   svt_Int = 10;             // Initialize value_type

   multiset <int> :: key_type skt_Int;   // Declare key_type
   skt_Int = 20;             // Initialize key_type

   ms1.insert( svt_Int );         // Insert value into s1
   ms1.insert( skt_Int );         // Insert key into s1

   // a multiset accepts key_types or value_types as elements
   cout << "The multiset has elements:";
   for ( ms1_Iter = ms1.begin( ) ; ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;
}

The multiset has elements: 10 20.

Voir aussi

conteneurs
Sécurité des threads dans la bibliothèque C++ Standard
Informations de référence sur la bibliothèque standard C++

Partager via

La classe multiset

Syntaxe

Paramètres

Notes

Constructeurs

Typedefs

Fonctions Membre

Opérateurs

Spécifications

multiset::allocator_type

Notes

Exemple

multiset::begin

Valeur de retour

Exemple

multiset::cbegin

Valeur de retour

Notes

multiset::cend

Valeur de retour

Notes

multiset::clear

Exemple

multiset::const_iterator

Notes

Exemple

multiset::const_pointer

Notes

multiset::const_reference

Exemple

multiset::const_reverse_iterator

Notes

Exemple

multiset::contains

Paramètres

Valeur de retour

Notes

Exemple

multiset::count

Paramètres

Valeur de retour

Notes

Exemple

multiset::crbegin

Valeur de retour

Notes

Exemple

multiset::crend

Valeur de retour

Notes

Exemple

multiset::difference_type

Notes

Exemple

multiset::emplace

Paramètres

Valeur de retour

Notes

Exemple

multiset::emplace_hint

Paramètres

Valeur de retour

Notes

multiset::empty

Valeur de retour

Exemple

multiset::end

Valeur de retour

Notes

multiset::equal_range

Paramètres

Valeur de retour

Exemple

multiset::erase

Paramètres

Valeur de retour

Notes

multiset::find

Paramètres

La classe `multiset`

`multiset::allocator_type`

`multiset::begin`

`multiset::cbegin`

`multiset::cend`

`multiset::clear`

`multiset::const_iterator`

`multiset::const_pointer`

`multiset::const_reference`

`multiset::const_reverse_iterator`

`multiset::contains`

`multiset::count`

`multiset::crbegin`

`multiset::crend`

`multiset::difference_type`

`multiset::emplace`

`multiset::emplace_hint`

`multiset::empty`

`multiset::end`

`multiset::equal_range`

`multiset::erase`

`multiset::find`

`multiset::get_allocator`

`multiset::insert`

`multiset::iterator`

`multiset::key_comp`

`multiset::key_compare`

`multiset::key_type`

`multiset::lower_bound`

`multiset::max_size`

`multiset::multiset`

`multiset::operator=`

`multiset::pointer`

`multiset::rbegin`

`multiset::reference`

`multiset::rend`

`multiset::reverse_iterator`

`multiset::size`

`multiset::size_type`

`multiset::swap`

`multiset::upper_bound`

`multiset::value_comp`