Måter å initialisere et STD -sett i C ++
"rød", "oransje", "gul", "grønn", "blå", "indigo", "Violet"
Dette er et eksempel på et sett bokstavelig i matematikk så vel som i C++. Det er også en matrise bokstavelig. Det er et sett med strenger. Sett med heltall, flyter, dobler osv., er også mulig.
STD står for standard. Denne artikkelen er på måter å initialisere et sett som kode. Det er en fast klasse i en modul i C ++ standardbiblioteket. Initialisering her, betyr å gi verdier til settet på skapelsestidspunktet. Å lage et sett er å konstruere settet.
Et sett kan konstrueres med de opprinnelige verdiene. Et sett kan også konstrueres tom.
Set -modulen (underbiblioteket) må inkluderes i programmet før et angitt objekt kan opprettes og initialisere det samtidig. Et C ++ -program som involverer sett bør begynne som følger:
#inkludere
#inkludere
ved hjelp av navneområdet STD;
Den første linjen i dette kodesegmentet inkluderer IOSTREAM (SUB) biblioteket. Hvis utgang (og inngang) er for terminalen (konsollen), må IOSTREAM -biblioteket inkluderes. Den andre linjen inkluderer SET (SUB) biblioteket; Dette er et must. Den tredje linjen er ikke et direktiv; Det er en uttalelse. Det insisterer på at ethvert navn som brukes uten foregående det med et navn på brukeren, er fra C ++ Standard navneområdet.
Resten av denne artikkelen forklarer forskjellige måter å initialisere settet under konstruksjon med de forskjellige konstruksjonsmetodene. På slutten av artikkelen blir det adressert å legge til (sette inn) verdier i det tomme settet.
sett (initializer_list, const compare & = compare (), const allocator & = allocator ())
Dette er en konstruktør for å lage et sett. Det første argumentet er settet Initializer_list. Initializer_list er settet bokstavelig. Det er det samme som matrisen bokstavelig. Hvis andre og tredje argumenter ikke er skrevet, vil standardargumentene deres bli ansatt. Følgende program viser denne konstruktøren i aksjon med initialiseringen:
#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()
Sett ST ("Red", "Orange", "Yellow", "Green", "Blue", "Indigo", "Violet");
for (sett :: iterator iter = st.begynne(); iter != ST.slutt(); iter ++)
cout << *iter << ", ";
cout << endl;
retur 0;
Utgangen er:
blå, grønn, indigo, oransje, rød, fiolett, gul,
Legg merke til at utgangen er sortert i stigende rekkefølge, mens inngangen (første argument) ikke ble sortert.
Legg også merke til at for å bruke strenger, må strengklassen inkluderes; Ellers er det pekerne på strengene som vil bli sortert, og ikke streng alfabetiske litteraler selv.
sett & operatør = (initializer_list)
Dette er kopikonstruktørformen til den ovennevnte konstruktøren. Det gjør fortsatt initialisering. Følgende program viser denne konstruktøren i aksjon med initialiseringen:
#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()
Sett ST = "Red", "Orange", "Yellow", "Green", "Blue", "Indigo", "Violet";
for (sett :: iterator iter = st.begynne(); iter != ST.slutt(); iter ++)
cout << *iter << ", ";
cout << endl;
retur 0;
Utgangen er:
blå, grønn, indigo, oransje, rød, fiolett, gul,
Legg merke til at utgangen er sortert i stigende rekkefølge, mens inngangen (første argument) ikke ble sortert.
sett (const set & x)
Denne konstruktøren oppretter et andre sett ved hjelp av identifikatoren til et tidligere sett som argument. Umiddelbart etter opprettelsen er det to eksemplarer av det samme innholdet. Følgende program viser denne konstruktøren i aksjon med initialiseringen:
#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()
Sett ST = "Red", "Orange", "Yellow", "Green", "Blue", "Indigo", "Violet";
Sett ST2 (ST); // Initialisering
for (sett :: iterator iter = ST2.begynne(); iter != ST2.slutt(); iter ++)
cout << *iter << ", ";
cout << endl;
retur 0;
Utgangen er:
blå, grønn, indigo, oransje, rød, fiolett, gul,
Legg merke til at utgangen er sortert i stigende rekkefølge, mens inngangen (første argument) ikke ble sortert.
sett & operatør = (const set & x)
Dette er en ekte kopikonstruktør. Det gjør fortsatt initialisering. Følgende program viser denne konstruktøren i aksjon med initialiseringen:
#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()
Sett ST = "Red", "Orange", "Yellow", "Green", "Blue", "Indigo", "Violet";
Sett ST2 = ST; // Initialisering
for (sett :: iterator iter = ST2.begynne(); iter != ST2.slutt(); iter ++)
cout << *iter << ", ";
cout << endl;
retur 0;
Utgangen er:
blå, grønn, indigo, oransje, rød, fiolett, gul,
Legg merke til at utgangen er sortert i stigende rekkefølge, mens inngangen (første argument) ikke ble sortert.
Templatesett (InputIterator First, InputIterator Last, Const Compare & Comp = Compare (), Const Allocator & = Allocator ());
Denne konstruktøren vil lage et nytt sett ved å kopiere en rekke verdier fra et annet sett. Rekkevidden begynner fra verdien som først peker på av og til, men ikke inkludert verdien som ble pekt på av sist. Hvis de andre argumentene for konstruktøren ikke er skrevet, vil standardargumentene deres bli ansatt. Malargumentet er iteratorklassen. Følgende program viser denne konstruktøren i aksjon med initialiseringen:
#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()
Sett ST = "Red", "Orange", "Yellow", "Green", "Blue", "Indigo", "Violet";
Sett :: Iterator Iterf = ST.begynne(); iterf ++;
Sett :: iterator iterl = ST.slutt(); iterl--;
Sett ST2 (Iterf, Iterl); // Initialisering
for (sett :: iterator iter = ST2.begynne(); iter != ST2.slutt(); iter ++)
cout << *iter << ", ";
cout << endl;
retur 0;
Utgangen er:
grønn, indigo, oransje, rød, fiolett,
Noe som ikke er akkurat det som kan ha vært forventet. Årsaken er som følger:
Innspillet er:
"rød", "oransje", "gul", "grønn", "blå", "indigo", "Violet"
Så det kan ha blitt forventet at "rød" og "fiolett" ville bli utelatt. I stedet var den "blå" og "gul" som ble utelatt. Nå, når et uordnet sett blir lagt inn i et sett, blir det sortert. Fra den sorterte listen ble verdiene i de ekstreme ender utelatt.
Tom sett og sett inn ()
Følgende program oppretter et tomt sett før verdiene settes inn:
#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int main ()
Sett ST;
st.Sett inn ("rød"); st.Sett inn ("oransje"); st.sett inn ("gul"); st.Sett inn ("grønn");
st.Sett inn ("Blå"); st.Sett inn ("indigo"); st.Sett inn ("Violet");
for (sett :: iterator iter = st.begynne(); iter != ST.slutt(); iter ++)
cout << *iter << ", ";
cout << endl;
retur 0;
Utgangen er:
blå, grønn, indigo, oransje, rød, fiolett, gul,
Legg merke til at utgangen er sortert i stigende rekkefølge, mens inngangen (første argument) ikke ble sortert.
Konklusjon
Initialisering er når verdier legges til når settet opprettes. Etter denne fasen blir verdiene sortert stigende med standardinnstillinger. De vanlige måtene å initialisere et sett i C ++ innebærer konvensjonell konstruksjon og kopikonstruksjon. De har blitt forklart ovenfor.
Chrys