Façons d'initialiser un ensemble de MST en C ++

"rouge", "orange", "jaune", "vert", "bleu", "indigo", "violet"

Ceci est un exemple d'un ensemble littéral en mathématiques ainsi qu'en C++. C'est aussi un plateau littéral. C'est un ensemble de cordes. Ensembles d'entiers, flotteurs, doubles, etc., sont également possibles.

STD signifie Standard. Cet article est sur les moyens d'initialiser un ensemble en tant que code. Il y a une classe définie dans un module dans la bibliothèque standard C ++. L'initialisation ici, signifie donner des valeurs à l'ensemble au moment de la création. La création d'un ensemble construit l'ensemble.

Un ensemble peut être construit avec les valeurs initiales. Un ensemble peut également être construit vide, puis les valeurs insérées après la création.

Le module SET (sous-bibliothèque) doit être inclus dans le programme avant qu'un objet défini ne puisse être créé et l'initialiser en même temps. Un programme C ++ qui implique des ensembles doit commencer comme suit:

#inclure
#inclure
Utilisation de Namespace Std;

La première ligne de ce segment de code comprend la bibliothèque ioStream (sub). Si la sortie (et l'entrée) est pour le terminal (console), alors la bibliothèque ioStream doit être incluse. La deuxième ligne comprend la bibliothèque set (sub); C'est un must. La troisième ligne n'est pas une directive; c'est une déclaration. Il insiste sur le fait que tout nom utilisé sans le précéder d'un nom d'espace de noms d'utilisateur provient de l'espace de noms standard C ++.

Le reste de cet article explique différentes façons d'initialiser l'ensemble pendant la construction avec les différentes méthodes de construction. À la fin de l'article, l'ajout de valeurs (d'insertion) à l'ensemble vide est adressée.

set (initializer_list, const compare & = compare (), const allocator & = allocator ())

Ceci est un constructeur pour créer un ensemble. Son premier argument est le jeu initial_list. L'initialisation_list est le littéral défini. C'est la même chose que le littéral du tableau. Si les deuxième et troisième arguments ne sont pas tapés, leurs arguments par défaut seront utilisés. Le programme suivant montre ce constructeur en action avec son initialisation:

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

set st ("rouge", "orange", "jaune", "vert", "bleu", "indigo", "violet");
pour (set :: iterator iter = st.commencer(); iter != st.fin(); iter ++)
couter << *iter << ", ";
couter << endl;
retour 0;

La sortie est:

bleu, vert, indigo, orange, rouge, violet, jaune,

Notez que la sortie est triée par ordre croissant, tandis que l'entrée (premier argument) n'a pas été triée.

Notez également que pour utiliser les chaînes, la classe String doit être incluse; Sinon, ce sont les pointeurs des cordes qui seront triées, et non les littéraux alphabétiques de cordes eux-mêmes.

set & operator = (initializer_list)

Ceci est la forme du constructeur de copie du constructeur ci-dessus. Il fait toujours l'initialisation. Le programme suivant montre ce constructeur en action avec son initialisation:

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

set st = "red", "orange", "jaune", "vert", "bleu", "indigo", "violet";
pour (set :: iterator iter = st.commencer(); iter != st.fin(); iter ++)
couter << *iter << ", ";
couter << endl;
retour 0;

La sortie est:

bleu, vert, indigo, orange, rouge, violet, jaune,

Notez que la sortie est triée par ordre croissant, tandis que l'entrée (premier argument) n'a pas été triée.

set (const set & x)

Ce constructeur crée un deuxième ensemble en utilisant l'identifiant d'un ensemble précédent comme argument. Immédiatement après la création, il y a deux copies du même contenu. Le programme suivant montre ce constructeur en action avec son initialisation:

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

set st = "red", "orange", "jaune", "vert", "bleu", "indigo", "violet";
définir ST2 (ST); // initialisation
for (set :: iterator iter = st2.commencer(); iter != ST2.fin(); iter ++)
couter << *iter << ", ";
couter << endl;
retour 0;

La sortie est:

bleu, vert, indigo, orange, rouge, violet, jaune,

Notez que la sortie est triée par ordre croissant, tandis que l'entrée (premier argument) n'a pas été triée.

set & operator = (const set & x)

Ceci est un véritable constructeur de copie. Il fait toujours l'initialisation. Le programme suivant montre ce constructeur en action avec son initialisation:

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

set st = "red", "orange", "jaune", "vert", "bleu", "indigo", "violet";
Définir ST2 = ST; // initialisation
for (set :: iterator iter = st2.commencer(); iter != ST2.fin(); iter ++)
couter << *iter << ", ";
couter << endl;
retour 0;

La sortie est:

bleu, vert, indigo, orange, rouge, violet, jaune,

Notez que la sortie est triée par ordre croissant, tandis que l'entrée (premier argument) n'a pas été triée.

Template set (inputIterator First, inputIterator Last, const compare & comp = compare (), const allocator & = allocator ());

Ce constructeur créera un nouvel ensemble en copie une gamme de valeurs à partir d'un autre ensemble. La plage commence par la valeur indiquée par la première fois, et vers, mais sans compter la valeur indiquée par la dernière. Si les autres arguments pour le constructeur ne sont pas dactylographiés, leurs arguments par défaut seront utilisés. L'argument du modèle est la classe Itérator. Le programme suivant montre ce constructeur en action avec son initialisation:

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

set st = "red", "orange", "jaune", "vert", "bleu", "indigo", "violet";
set :: iterator iterf = st.commencer(); iterf ++;
set :: iterator iterl = st.fin(); iterl--;
set st2 (iterf, iterl); // initialisation
for (set :: iterator iter = st2.commencer(); iter != ST2.fin(); iter ++)
couter << *iter << ", ";
couter << endl;
retour 0;

La sortie est:

vert, indigo, orange, rouge, violet,

ce qui n'est pas exactement ce à quoi il aurait pu être attendu. La raison en est la suivante:

L'entrée est:

"rouge", "orange", "jaune", "vert", "bleu", "indigo", "Violet"

Il aurait donc pu s'attendre à ce que "rouge" et "violet" soient omis. Au lieu de cela, c'était "bleu" et "jaune" qui ont été omis. Maintenant, lorsqu'un ensemble non ordonné est entré dans un ensemble, il devient trié. À partir de la liste triée, les valeurs aux extrémités extrêmes ont été omises.

Set vide et insert ()

Le programme suivant crée un ensemble vide avant que les valeurs ne soient insérées:

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

Définir ST;
St.insérer ("rouge"); St.insérer ("orange"); St.insérer ("jaune"); St.insérer ("vert");
St.insérer ("bleu"); St.insérer ("indigo"); St.insérer ("Violet");
pour (set :: iterator iter = st.commencer(); iter != st.fin(); iter ++)
couter << *iter << ", ";
couter << endl;
retour 0;

La sortie est:

bleu, vert, indigo, orange, rouge, violet, jaune,

Notez que la sortie est triée par ordre croissant, tandis que l'entrée (premier argument) n'a pas été triée.

Conclusion

L'initialisation est lorsque des valeurs sont ajoutées lorsque l'ensemble est créé. Après cette phase, les valeurs deviennent triées avec des paramètres par défaut. Les façons courantes d'initialiser un ensemble en C ++ impliquent la construction et la construction de copies conventionnelles. Ils ont été expliqués ci-dessus.

Chrys