Fonctions de définition C ++

«Nous pouvons utiliser les nombreuses caractéristiques et outils bénéfiques de C ++ pour aider à la programmation dynamique. L'une de ces pièces est un ensemble trouvé dans la bibliothèque de modèles standard, qui offre un mécanisme pour stocker efficacement les données de manière organisée. Dans ce didacticiel C ++ Set, nous parlerons de toutes les bases des fonctions C ++ Set.

Les structures de C ++ STL pour maintenir les éléments dans un ordre spécifique sont appelées ensembles. Un ensemble doit avoir des composants uniques. Chaque élément d'un ensemble peut être identifié par sa valeur individuellement, donc ils servent de clés. En C ++, nous pouvons ajouter et supprimer des éléments d'un ensemble; Cependant, nous ne pouvons pas modifier les valeurs des composants car ils sont statiques après avoir été placés dans l'ensemble."

Définition de l'ensemble en C++

Comme il est déjà indiqué, les ensembles ne sont que le type de conteneurs de bibliothèque de modèles standard utilisés en C ++ pour stocker les articles avec précision. Les ensembles ne peuvent être soumis qu'aux méthodes d'insertion et de suppression. Dans un objet de type défini, les éléments sont automatiquement organisés dans un ordre spécifié. Nous ne pouvons pas modifier ou mettre à jour les valeurs des composants déjà existants dans un ensemble car les éléments dans les conteneurs sont immuables. En le définissant précisément, un élément dans un ensemble sert de clé pour lui-même. Les ensembles ne peuvent contenir qu'une valeur spécifique.

Quand utiliser des ensembles?

En programmation compétitive, les ensembles sont largement utilisés comme conteneurs. Lorsqu'il est nécessaire de stocker des articles de manière catégorisée, nous pouvons envisager d'utiliser des ensembles, mais gardez à l'esprit que les ensembles ne permettent pas le stockage de valeurs répétées. Une fois qu'il a été entré, la valeur ne peut pas être modifiée.

Implémentation des ensembles

Pour interagir avec les ensembles, les 2 fichiers d'en-tête principaux doivent être intégrés. Les ensembles sont accessibles en utilisant des itérateurs. Intégrer #include et #include dans votre code. Nous avons le choix d'utiliser juste ce fichier d'en-tête plutôt que ces deux. La bibliothèque sert de substitut aux fichiers d'en-tête mentionnés ci-dessus. Nous ne pouvons employer ce fichier d'en-tête que car il intègre tous les fichiers d'en-tête. Les arbres de recherche binaires sont utilisés pour définir des ensembles au niveau interne.

Définir les caractéristiques en C++

Voici quelques-uns des attributs d'ensemble communs en C ++:

• La caractéristique de l'unicité: en C ++, chaque membre d'un ensemble doit être distinct; Les éléments répétés ne sont pas acceptés. En conséquence, les installations de C ++ ne prennent pas en charge la répétition.
• La caractéristique de l'organisation: les composants d'un conteneur défini sont généralement enregistrés de manière organisée.
• La possibilité d'être immuable: une fois les éléments enregistrés dans un ensemble, ils ne peuvent pas être modifiés. En conséquence, bien que l'ajout et la suppression soient autorisés, la mise à jour ou la modification des composants existants de l'ensemble n'est pas requis.
• L'attribut de l'exécution interne: un BST est utilisé pour créer logiquement un ensemble en C++.
• La fonctionnalité de l'indexation: comme la bibliothèque de modèles standard C ++ ne fournira pas d'indexation, les décors en C ++ ont également la fonctionnalité d'être non indexé.

Syntaxe de l'ensemble

Ce qui suit est la déclaration STD :: SET de la bibliothèque «Set»:

Paramètres

• Clé: Type du composant représenté dans la clé. Toute autre structure de données, comme un type défini par l'utilisateur, pourrait être utilisée à la place de la clé.
• ALLOCATEURS: Ce seront les objets chargés d'incorporer l'administration du stockage. Chaque fois que nous voulons séparer l'allocation et effectuer la création en 2 phases, nous devons utiliser l'allocateur STD ::. Lorsque l'élimination séquentielle et la mémoire dynamique sont effectuées en 2 phases, il est également utilisé. La valeur de retour pour l'allocateur d'argument de type dans tous les conteneurs est std :: allocateur. Les opérateurs nouveaux et effacer sont tout ce que l'allocateur de base utilise pour acquérir et soulager le stockage.
• Comparer: Un attribut binaire avec deux paramètres ayant un type similaire à celle des composants et une valeur de retour bool. Si un élément est considéré comme avant la clé du séquençage que la fonction définit, l'instruction comp (x, y), où comperait un objet de ce type et x et y sont des valeurs clés, doit donc générer True. Cette déclaration est utilisée par l'objet défini pour évaluer la disposition des composants à l'intérieur du conteneur ainsi que si deux clés d'élément sont égales (en les comparant instinctivement: elles sont égales si! comp (x, y) &&!comp (y, x)).

Un conteneur réglé peut contenir des composants uniques. Cela peut être soit un objet de fonction ou un pointeur de fonction. Moins est la valeur par défaut, et elle fournit les mêmes résultats que l'utilisation de l'expression moins que (x

Fonctions sur les ensembles

En C ++, les ensembles pourraient être soumis à une grande variété d'opérations. Évaluons certaines des principales techniques d'ensemble.

• Fonction begin (): un itérateur pointant vers le premier élément de l'ensemble est renvoyé par cette fonction.
• Fonction end (): cette méthode fournit un itérateur pointant vers le point adjacent au dernier élément de l'ensemble dans l'approche théorique.
• Fonction vide (): il est utilisé pour déterminer si l'ensemble est vide ou non.
• Méthode size (): il fournit le nombre total d'éléments dans un ensemble.
• Fonction max_size (): il récupère la limite supérieure des éléments d'un ensemble ou la valeur plus élevée qu'un ensemble peut accueillir.
• Rbegin (): cette fonction, en revanche pour commencer (), fournit un itérateur inversé qui pointe la valeur finale d'un ensemble.
• Rend (): Contrairement à la fonction fin (), il fournit un itérateur inversé qui pointe logiquement l'endroit avant la toute dernière valeur d'un ensemble.
• Fonction Erase (): lorsqu'elle est utilisée sur un ensemble, il élimine l'élément à l'emplacement indiqué par le pointeur spécifié dans le paramètre.
• Effacer (const_n): Cette méthode supprime immédiatement la valeur «n» d'un ensemble lorsqu'elle est fournie comme argument.
• INSERT (const n): cette méthode ajoute un nouveau membre, «n», à l'ensemble.
• Find (n): il trouve l'ensemble de l'élément défini et fournit un itérateur faisant référence à l'emplacement du composant qui a été identifié. Il produit un itérateur pointant vers la fin de l'élément qui ne peut pas être récupéré.
• Count (const n): cette fonction compte le nombre de fois que la valeur fournie «n» apparaît et fournit 0 ou 1 selon que l'élément a été récupéré ou non.
• Clear () Fonction: il élimine chaque élément d'un ensemble.

Exemple n ° 1

Dans ce cas, un ensemble sera initialisé. En C ++, nous spécifions les différents types d'éléments qui seront placés dans un ensemble lors de sa création. Les points de données d'un ensemble sont généralement stockés dans l'ordre croissant. La plus grande fonction pourrait être utilisée pour conserver les données dans l'ordre descendant. Vide

• En utilisant des valeurs
• Utilisation d'un tableau.
• En utilisant un autre ensemble.

Ce sont de nombreuses techniques pour déclarer un ensemble.

#inclure
#inclure
Utilisation de Namespace Std;
int main()

sets1;
ensembleS2;
ensemble S3 = 62, 17, 25, 81;
ensemble S4 (S3);
int ar [] = 15, 24, 75, 51;
Set S5 (AR, AR + 4);
set :: iterator i;
pour (auto i = s5.commencer(); je!= S5.end (); i ++)

couter<
retour 1;

Les fichiers d'en-tête et seraient intégrés en premier. Après cela, l'espace de noms standard sera utilisé. La fonction principale () sera appelée. Le premier ensemble sera initialisé, et ce sera un ensemble vide car il ne contient aucun élément. Le deuxième ensemble sera déclaré comme un ensemble vide dans l'ordre descendant. Le nouvel ensemble sera initialisé en y ajoutant différents entiers. Cet ensemble contient quatre éléments.

De plus, nous initialiserons un nouvel ensemble nommé «S4» par l'utilisation d'un autre ensemble, «S3». Nous avons fourni les valeurs du S3 comme paramètres du S4. Maintenant, l'ensemble sera déclaré à partir d'un tableau. Nous spécifions les valeurs dans le tableau, puis enregistrons ces valeurs dans une variable «A». Le cinquième ensemble contient les 4 valeurs du tableau. Ensuite, nous définirons l'itérateur pour ces ensembles requis. Nous acquérerions les valeurs de tous les ensembles par l'utilisation de la boucle «pour».

Exemple n ° 2

Cette illustration montre comment fonctionne les méthodes d'insertion et de suppression de l'ensemble.

#inclure
Utilisation de Namespace Std;
int main()

définir S1;
S1.insérer (22);
S1.insérer (33);
S1.insérer (56);
S1.insérer (9);
S1.insérer (67);
S1.insérer (47);
S1.insérer (88);
set :: iterator p_1, p_2, p_3;
couter<< " The values of the set are: \n" ;
pour (p_1 = s1.commencer() ; p_1 != S1.fin() ; p_1 ++)

couter<< *p_1 << " " ;

couter<ensemble S2 (S1.begin (), s1.fin() );
ensemble :: Iterator i;
p_2 = s1.trouver (22);
p_3 = s1.trouver (88);
S1.Effacer (p_2, p_3);
couter<< " The values of the set after using erase() function: \n " ;
pour (p_1 = s1.commencer() ; p_1 != S1.fin() ; p_1 ++)

couter<< *p_1 << " ";

couter<couter<< " The values of second set are: \n" ;
pour (i = s2.commencer() ; je != S2.fin() ; i ++)

couter<< *i<< " ";

retour 0;

Les bibliothèques requises seront incluses au début du programme. L'espace de noms standard sera ajouté en tant que «MST». Maintenant, la méthode principale () sera invoquée. Déclarons différents ensembles. Nous appellerions la méthode insert () pour ajouter les valeurs dans l'ensemble. Différents pointeurs seront créés et nommés "P_1", "P_2" et "P_3". L'itérateur sera déclaré comme ces pointeurs. La déclaration «cout» sera utilisée pour représenter la ligne «Les valeurs de l'ensemble sont». Maintenant, la boucle «pour» sera utilisée pour afficher toutes les valeurs insérées de l'ensemble.

Le début () serait appelé pour démarrer les valeurs de l'ensemble à imprimer, et les méthodes fin () seraient appliquées pour terminer les valeurs de l'ensemble. Ces méthodes seront invoquées à l'intérieur de la boucle «pour». Le constructeur du premier pointeur sera défini dans l'instruction «cout». Maintenant, nous ferons un autre ensemble en organisant les valeurs dans l'ordre descendant. Les éléments des premier et deuxième ensembles requis sont les mêmes.

La fonction find () serait appelée sur les éléments du premier ensemble défini. Cette fonction obtient les valeurs définies de l'ensemble. Maintenant, nous appliquerions la méthode effacer () pour supprimer les valeurs du premier ensemble. Les valeurs qui seront supprimées sont de 22 à 88. L'instruction «cout» sera utilisée pour afficher le texte «Les valeurs de l'ensemble après avoir utilisé la fonction Erase ()». Pour montrer les valeurs, la boucle «pour» sera utilisée.

Alors le constructeur du premier pointeur sera déclaré. Maintenant, nous utilisons la boucle «pour» pour imprimer les éléments du deuxième ensemble requis. L'instruction «cout» imprime la ligne «Les valeurs du deuxième ensemble sont». Avant d'ajouter la commande «return 0», le constructeur de la variable Iterator sera créé.

Exemple n ° 3

Dans cet exemple, deux fonctions, find () et effacer, seront utilisées. Si l'élément est identifié, la méthode find () produit un itérateur qui y fait référence; Sinon, il fournit un itérateur faisant référence à la fin de l'ensemble. Les éléments de l'ensemble seront supprimés à l'aide de la fonction effacer ().

#inclure
Utilisation de Namespace Std;
int main()

sets_1;
S_1.insérer (45);
S_1.insérer (12);
S_1.insérer (17);
S_1.insérer (89);
S_1.insérer (25);
S_1.insérer (14);
S_1.insérer (78);
S_1.insérer (34);
set :: iterator i;
couter<<"Values of required set: \n";
pour (i = s_1.commencer() ; je != S_1.fin() ; i ++)

couter<<*i<< " ";

couter<couter<< " Updated set \n " ;
S_1.Effacer (S_1.begin (), s_1.trouver (25));
pour (i = s_1.commencer() ; je!= S_1.fin() ; i ++)
couter<< *i<< " " ;
couter<couter<< " lower bound of 45 is: \n" ;
couter<< *s_1.lower_bound( 45 )<couter<< " lower bound of 17 is: \n" ;
couter<< *s_1.lower_bound( 17 ) <couter<< " upper bound of 45 is: \n" ;
couter<< *s_1.upper_bound( 45 ) <couter<< "upper bound of 17 is: \n" ;
couter<< *s_1.upper_bound( 17 ) <retour 0;

Le programme comprendra les bibliothèques pertinentes au début appelé . L'espace de noms standard en tant que «MST» sera introduit. Une référence à la fonction principale () sera désormais faite. Spécifiez d'abord l'ensemble. Pour inclure les valeurs dans l'ensemble, nous utiliserions la fonction insert (). L'itérateur sera identifié comme «I»; Les valeurs de l'ensemble approprié seront affichées à l'aide de la commande «cout». La boucle «pour» sera désormais utilisée pour afficher toutes les valeurs insérées de l'ensemble.

La fonction début () serait utilisée pour commencer à imprimer les valeurs de l'ensemble, et la méthode fin () serait utilisée pour terminer l'impression des valeurs de l'ensemble. Ces méthodes définies seraient utilisées à l'intérieur de la boucle «pour». La déclaration «cout» déclarera le constructeur de l'itérateur. Le texte «Set mis à jour» sera affiché à l'aide de l'instruction COUT. Les composants du premier ensemble seraient déterminés en utilisant la fonction Find (). Les valeurs définies sont obtenues par cette fonction à partir de l'ensemble.

Pour supprimer les valeurs du premier ensemble, nous allons maintenant utiliser la méthode effacer (). Jusqu'à 25 valeurs seront éliminées. À l'aide d'une boucle «pour», les entiers restants seront présentés. La déclaration «cout» fournira une déclaration du constructeur de l'itérateur. Les opérations de limite inférieure et supérieure sur les valeurs de l'ensemble seront effectuées. Les valeurs 45 et 17 de l'ensemble seraient fournies à la fonction Bound () inférieure, qui utiliserait ensuite la commande «cout» pour imprimer le résultat. Ces valeurs similaires dans l'ensemble seront traitées sur une méthode Upper Bound (). La valeur du résultat sera imprimée par la commande «cout». La commande «retour 0» sera ajoutée à la fin.

Conclusion

Nous avons discuté des fonctions de définition C ++ dans ce guide. Semblable à d'autres packages de bibliothèque standard, l'ensemble C ++ est crucial. Il permet aux développeurs d'extraire et de manipuler plus facilement les valeurs. Nous avons mis en œuvre trois programmes. L'initialisation des ensembles est gérée dans le premier exemple. Le second affiche les ajouts et les éliminations des valeurs de l'ensemble. Dans le dernier cas, nous choisissons quelques valeurs de l'ensemble, puis les supprimons.