Partager via


La classe multiset

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.

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 .

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.
containsC++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.

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.

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++