set Class

Le jeu de classe de conteneur STL est utilisé pour le stockage et la récupération des données d'une collection dans laquelle les valeurs des éléments contenus sont uniques et le sert de valeurs de clés d'après laquelle les données sont triées automatiquement.La valeur d'un élément dans un jeu ne peut être modifié directement.À la place, vous devez supprimer les anciennes valeurs et des éléments d'insertion avec de nouvelles valeurs.

template <
    class Key, 
    class Traits=less<Key>, 
    class Allocator=allocator<Key> 
>
class set

Paramètres

• Key
  Le type de données d'élément à stocker dans le jeu.

• Traits
  Le type qui fournit un objet de fonction qui peut comparer deux valeurs d'élément comme clés de tri pour déterminer leur commande relative dans le jeu.Cet argument est facultatif, et l'attribut binaire less*<Key>* est la valeur par défaut.

• Allocator
  Le type qui représente l'objet d'allocation stocké qui encapsule des informations sur l'allocation et la libération du jeu de la mémoire.Cet argument est facultatif, et la valeur par défaut est allocator*<Key>.*

Notes

Un jeu STL est :

• Un conteneur associatif, qui un conteneur variable de taille qui prend en charge la recherche efficace des valeurs d'élément selon une valeur de clé associée.De plus, il s'agit d'un conteneur associatif simple car ses valeurs d'élément sont ses valeurs de clés.

• Réversible, car il fournit un itérateur bidirectionnel pour accéder à ses éléments.

• Trié, car ses éléments sont triés par les valeurs de clés dans le conteneur conformément à une fonction de comparaison donnée.

• Unique dans le sens que chacun de ses éléments doit avoir une clé unique.Étant donné que le jeu est également un conteneur associatif simple, ses éléments sont également uniques.

Un jeu est également décrit comme une classe de modèle car les fonctionnalités qu'elle fournit est générique et indépendants du type de données spécifique contenu en tant qu'éléments.Le type de données à utiliser est en fait spécifié comme paramètre dans le modèle de classe avec la fonction de comparaison et l'allocateur.

Le choix du type de conteneur doit être basé généralement sur le type de rechercher et d'insérer requis par l'application.Les conteneurs sont associatifs optimisés pour les opérations de recherche, de l'insertion et de suppression.Les fonctions membres qui prennent en charge explicitement ces opérations sont efficaces, les exécutant dans une heure qui est en moyenne proportionnel au logarithme du nombre d'éléments dans le conteneur.Insertion des éléments n'invalide pas d'itérateur, et supprime des éléments invalide uniquement les itérateurs qui avaient spécifiquement pointe vers des éléments supprimés.

Le jeu doit être le conteneur du tableau associatif lorsque les conditions associant les valeurs avec leurs clés sont satisfaites par l'application.Les éléments d'un ensemble sont uniques et sert de leurs propres clés de tri.Un modèle pour ce type de structure est une liste triée par exemple des mots dans les mots peuvent se produire une seule fois.Si vous permettait de plusieurs occurrences des mots, un multiensemble est la structure appropriée du conteneur.Si les valeurs doivent être jointes à une liste de mots clés de clé unique, une carte est une structure appropriée pour contenir les données.Si à la place des clés ne sont pas uniques, un mappage multiple est le conteneur du tableau.

Le jeu classe la séquence qu'il contrôle en appelant un objet stocké de fonction de type key_compare.Cet objet stocké est une fonction de comparaison qui est accessible en appelant la fonction membre key_comp.En général les éléments doivent être simplement moins que comparables pour générer cette commande afin que, avec deux éléments quelconques, il puisse déterminer l'un ou l'autre qu'ils sont équivalents (dans le sens que ni l'un ni l'autre n'est inférieure à l'autre) ou qu'il est inférieure à l'autre.Cela provoque le classement entre les éléments d'inégalité.En plus de la note technique, la fonction de comparaison est un attribut binaire qui induit le classement faible strict dans le sens mathématiques standard.Un attribut fbinaire (*x, y)*est un objet de fonction qui a deux objets d'argument coordonnées et une valeur de retour de true ou de false.Le classement imposé à un ensemble est faible l'ordre strict si l'attribut 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 f(*x, y)*et f(*x, y)*sont fictifs.Si l'état plus fort de l'égalité entre les clés remplace celui de l'équivalence, le classement est total (dans le sens que tous les éléments sont triés par rapport à l'autre) et les clés correspondance seront imperceptibles entre eux.

L'itérateur fourni par la classe de positionnement est un itérateur bidirectionnel, mais le membre de classe s'exécute insérer et set ont des versions qui prennent comme paramètre de modèle un itérateur d'entrée plus faible, dont les spécifications de fonctionnalités sont plus minimales que celles garanties par la classe les itérateurs bidirectionnelles.Les différents concepts d'itérateur forment une famille associée par des améliorations dans leurs fonctionnalités.Chaque concept d'itérateur possède son propre ensemble de spécifications, et les algorithmes qui fonctionnent avec elles la limite de nécessité les hypothèses aux spécifications fournies par ce type d'itérateur.Il peut supposer 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 dans la séquence.C'est un jeu minimal de fonctionnalité, mais il est asse'à pouvoir parler clairement à propos d'une plage des itérateurs [_First, _Last) dans le contexte des fonctions membres de la classe.

Constructeurs

set	Construit un jeu qui est vide ou qui est une copie de l'ensemble ou une partie d'un autre ensemble.

Typedef

allocator_type	Un type qui représente la classe d' allocator pour l'objet de positionnement.
const_iterator	Un type qui fournit un itérateur bidirectionnel qui peut lire un élément d' const dans le jeu.
const_pointer	Un type qui fournit un pointeur vers un élément de const dans un jeu.
const_reference	Un type qui fournit une référence à un élément d' const stocker dans un positionnement pour lire et effectuer des opérations d' const .
const_reverse_iterator	Un type qui fournit un itérateur bidirectionnel qui peut lire un élément d' const dans le jeu.
difference_type	Un type d'entier signé qui peut être utilisé pour représenter le nombre d'éléments d'un jeu dans une plage entre les éléments a globale pointe vers les itérateurs.
itérateur	Un type qui fournit un itérateur bidirectionnel qui peut lire ou modifier un élément dans un jeu.
key_compare	Un type qui fournit un objet de fonction qui peut comparer deux clés de tri pour déterminer la commande relative de deux éléments du jeu.
key_type	Le type décrit un objet stocké comme un élément d'un positionnement dans sa qualité de clé de tri.
pointer	Un type qui fournit un pointeur vers un élément dans un jeu.
référence	Un type qui fournit une référence à un élément stocker dans un jeu.
reverse_iterator	Un type qui fournit un itérateur bidirectionnel qui peut lire ou modifier un élément dans un jeu inversé.
size_type	Un type d'entier non signé qui peut représenter le nombre d'éléments dans un jeu.
value_compare	Le type qui fournit un objet de fonction qui peut comparer deux éléments pour déterminer leur commande relative dans le jeu.
value_type	Le type décrit un objet stocké comme un élément d'un positionnement dans sa qualité de valeur.

Fonctions membres

begin	Retourne un itérateur qui traite le premier élément du jeu.
cbegin	Retourne un itérateur const qui traite le premier élément du jeu.
cend	Retourne un itérateur const qui traite l'emplacement réussissant le dernier élément d'un jeu.
clear	Efface tous les éléments d'un jeu.
count	Retourne le nombre d'éléments dans un ensemble de la clé correspond à une clé paramètre- spécifiée.
crbegin	Retourne un itérateur const adressant le premier élément dans un jeu inversé.
crend	Retourne un itérateur const qui traite l'emplacement réussissant le dernier élément d'un jeu inversé.
champ	Insère un élément construit en place en jeu.
emplace_hint	Insère un élément construit en place en jeu, avec un indicateur de positionnement.
empty	Teste si un ensemble est vide.
end	Retourne un itérateur qui traite l'emplacement réussissant le dernier élément d'un jeu.
equal_range	Retourne une paire d'itérateurs respectivement au premier élément dans un jeu avec une clé qui est supérieure à une clé spécifiée et au premier élément du jeu avec une clé à laquelle est égal ou supérieur à la clé.
effacement	Supprime un élément ou une plage d'éléments dans un jeu des positions spécifiées ou supprime des éléments qui correspondent à une clé spécifiée.
find	Retourne un itérateur adressant l'emplacement d'un élément dans un jeu qui a une clé équivalente à une clé spécifiée.
get_allocator	Retourne une copie de l'objet d' allocator utilisé pour construire le jeu.
insérer	Insère un élément ou une plage d'éléments en jeu.
key_comp	Extrait une copie de l'objet de comparaison utilisé à des clés de commande dans un jeu.
lower_bound	Retourne un itérateur au premier élément dans un jeu avec une clé à laquelle est égal ou supérieur une clé spécifiée.
max_size	Retourne la longueur maximale du jeu.
rbegin	Retourne un itérateur adressant le premier élément dans un jeu inversé.
rend	Retourne un itérateur qui traite l'emplacement réussissant le dernier élément d'un jeu inversé.
taille	Retourne le nombre d'éléments figurant dans le jeu.
échange	Permute les éléments de deux jeux.
upper_bound	Retourne un itérateur au premier élément dans un jeu avec une clé qui est supérieure à une clé spécifiée.
value_comp	Extrait une copie de l'objet de comparaison utilisé aux valeurs des éléments commandés dans un jeu.

Opérateurs

operator=

Remplace les éléments d'un jeu par une copie d'un autre ensemble.

Configuration requise

Header: <set>

l'espace de noms : DST

Voir aussi

Référence

Sécurité des threads dans la bibliothèque C++ standard

Modèles Standard