C ++ STD Transform

Std :: Transformfunksjon eksisterer i C ++ STL. Vi må omfatte overskriftsfilen for å bruke denne funksjonen. Denne metoden brukes til å utføre en operasjon på alle komponenter. Den bruker operasjoner på en eller flere matrisekomponenter i sekvens og lagrer utgangen i den resulterende matrisen. Denne tilnærmingen fungerer på to måter. Disse er:

Unary Operation: Dette brukes på hvert element i inngangsserien, og utgangen lagres i en annen matrise.

Binær drift: Denne operasjonen brukes på hvert element i den første inngangsserien og den tilsvarende komponenten i den andre inngangsserien. I likhet med Unary -operasjonen lagres også resultatet i utgangsarrayen.

Verken Unary Operation eller Binary Operation endrer direkte komponenten som er passert som en parameter. Hvis utgangen spesifiserer den samme serien, endres de indirekte av algoritmen. La oss diskutere STD :: Transform -funksjonen og dens modus i detalj.

Unary Operation:

STD :: Transform relaterer den spesifiserte funksjonen til ett område og lagrer utgangen i et annet område. Denne teknikken utfører en unary -operasjon på komponentene i serien (Array, Array+12) og lagrer deretter utdataene i serien som starter med resultatet.

Det påfølgende programmet viser hvordan du utfører unary -operasjoner på en matrise. Transform () -funksjonen mottar en peker til de første og endelige posisjonene til en matrise og startposisjonen til den resulterende matrisen.

#inkludere
#inkludere
ved hjelp av navneområdet STD;
int square (int m)
return m*m;

int main (int lmn, char ** pqr)
int Array [12] = 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26;
int resultat [12];
Transform (Array, Array+12, Resultat, Square);
for (int j = 0; j<12; j++)
cout <

Ved å inkludere bibliotekene, skal vi starte programmet. Toppfilen # inkluderer er for inngangs- og utgangsformål. Derfor brukes overskriftsfilen # for transformasjonsfunksjonen for transformasjon (). Vi definerer datatypen heltall til Unary -operasjonen. Vi definerer også en heltalldatatype til dens variable 'M'.

Videre definerer vi kvadratfunksjonen ved å ta kvadratet på variabelen. I hoveddelen erklærer vi matrisen. Vi tar 12 til og med tall i matrisen. Datatypen på inngangsoppstillingen og den resulterende matrisen er lik. Utgangen lagres i en ny matrise. Deretter bruker vi transformasjonsfunksjonen (). Denne funksjonen iteratorer til start- og sluttposisjonene til en serie. Serien bruker (Array, Array+12), som inkluderer alle komponenter i inngangsarrayen. Den inneholder også komponenten som matrisen peker på.

Her er den resulterende matrisen en output iterator, og den itereres til starten av serien der utgangen er lagret. Unary -funksjonen tar en komponent i kategorien som er pekt på matrisen som et argument og ga deretter en verdi som den resulterende matrisen kan endre. Unary -operasjonen gjelder serien definert i (Array, Array+12). Dette bruker en metode for hver komponent i en serie. Endelig bruker vi for loop. Hvert element er trykt på en ny linje.

Binær drift:

Denne teknikken utfører den binære operasjonen på komponentene i serien (første element, siste element) med komponenten til stede i den andre posisjonen i serien. Det sparer resultatet i serien, og starter med resultatet. Transform () bruker en funksjon som tar to komponenter og mottar to parametere fra inngangsserien for hvert par komponenter. I dette programmet utfører vi binære operasjoner på de spesifiserte dataene. Hvis det er behov for å legge til komponenter fra to matriser, bruker vi den binære operatørmetoden.

#inkludere
#inkludere
#inkludere
ved hjelp av navneområdet STD;
int operator_increment (int k, int l)
return k+l;

int main ()
int a = 8;
int inp_arr1 [] = 4, 7, 12, 36, 75, 23, 48, 69;
int inp_arr2 [] = 2, 15, 6, 95, 8, 73, 4, 80;
int otp_arr [a];
std :: cout <<"First array:";
for (int k = 0; kcout <<" <
cout <<'\n';
std :: cout <<"Second array:";
for (int k = 0; kcout <<" <
cout <<'\n';
STD :: Transform (INP_ARR1, INP_ARR1+A, INP_ARR2, OTP_ARR, OPERATION_INCRING);
std :: cout <<"Resultant array:";
for (int k = 0; k<8; k++)
cout <<" << otp_arr[k];

cout <<'\n';
retur 0;

I dette tilfellet integrerer vi en ny overskriftsfil som brukes til std :: transform og en annen headerfil #include brukes til std :: vektor. Nå bruker vi den binære funksjonen etter transformasjonsfunksjonen. Vi erklærer to variabler 'K' og 'L' her, og det returnerer tilsetningen av 'K' -variabelen til 'L' -variabelen. Videre definerer vi to forskjellige matriser. Det er 8 elementer i hver matrise. Og for å representere dette, bruker vi variabelen 'A'.

Datatypen på matriser er et heltall. Utgangen lagres i en ny matrise som er representert av 'OTP_ARR'. Vi ønsker å skrive ut teksten 'First Array'; Derfor bruker vi cout -funksjonen. Vi søkte om sløyfe for den første inngåtte matrisen. Ved dette får vi elementene i den første matrisen. Vi bruker Newline -karakteren '\ n'.

Deretter bruker vi igjen en for loop for å få den andre matrisen. Hoveddelen av programmet er å bruke transformasjonsfunksjonen for disse matriser. Denne funksjonen tar det første og siste elementet i den første matrisen, det første elementet i den andre matrisen, og det første elementet i den resulterende matrisen. Deretter brukes den binære funksjonen på to matriser. STD :: Transform () -metoden bruker en binær operatør for hver komponent i området og sparer returverdien. På samme måte får vi den resulterende matrisen. Vi søkte også om sløyfe for den resulterende matrisen.

Denne funksjonen får også begynnelsen på utgangsarrayen og en peker til den binære funksjonen, som gjelder de to definerte matriser. Den binære funksjonen godtar to komponenter (henholdsvis en fra hver av de to seriene) som argumenter. Og den returnerer en matrise som blir transformert til datatypen OTP_ARR.

Tillegg av to vektorer:

Vi kan bruke STD :: Transform Function for å gjøre målserien som ligner på inngangsserien og utføre en endring på stedet. Det etterfølgende eksemplet viser hvordan man bruker binære oversettelser.

#inkludere
#inkludere
#inkludere
#inkludere
int op_increase (int j) return ++ j;
int main ()
std :: vektorABC;
std :: vektorxyz;
for (int j = 1; j<8; j++)
ABC.push_back (j*20);
xyz.Endre størrelse (ABC.størrelse());
Std :: Transform (ABC.Begynn (), ABC.slutt (), xyz.begynn (), op_increase);
Std :: Transform (ABC.Begynn (), ABC.slutt (), xyz.Begynn (), ABC.Begynn (), STD :: Plus());
std :: cout <<"Output";
for (std :: vektor:: Iterator IT = ABC.begynne(); den!= ABC.slutt(); ++ det)
std :: cout <<" <<*it;
std :: cout <<'\n';
retur 0;

Når programmet starter, blir først bibliotekene integrert. #include Library brukes på STD :: Transform Function. #include gjelder STD :: Vektorfunksjonen. #include relaterer std :: pluss metode. Funksjonen op_increase () brukes for konverteringer for å øke verdsettelsen av parametrene.

Vi integrerer to vektorer, og datatypene deres er like. Etter å ha erklært for sløyfe, bruker vi STD :: Transform -funksjonen. Vi erklærer 8 elementer i for loop. I Transform () -funksjonen er serien brukt er (ABC.Begynn, ABC.slutt), som inkluderer alle komponenter mellom ABC.Begynn og ABC.slutt. Her XYZ.Begynn iterater til startstedet til den andre serien. STD :: Plus () er en innebygd funksjon og brukes i en binær konvertering for å legge til to vektorer. Utfallet av den ovennevnte koden ser slik ut:

Konklusjon:

Denne artikkelen har forklart Std :: Transform -funksjonen. Funksjonen brukes på to måter. En unary -funksjon tar bare en komponent som argument og gir tilbake en verdi. En binær funksjon som tar to komponenter (en fra hver eneste av de to seriene) som argumenter, og deretter returnerer den en resulterende verdi. Den binære operasjonen gjelder alltid for par av komponenter i to områder. Den relaterer den spesifiserte funksjonen til en serie og lagrer utgangen i en annen serie.