C ++ STD -Transformation

STD :: Transformationsfunktion existiert in C ++ Stl. Wir müssen die Header -Datei umfassen, um diese Funktion zu verwenden. Diese Methode wird verwendet, um einen Vorgang für alle Komponenten durchzuführen. Es wendet Vorgänge nach einer oder mehreren Array -Komponenten nacheinander an und speichert die Ausgabe im resultierenden Array. Dieser Ansatz funktioniert auf zwei Arten. Diese sind:

Unary Operation: Dies wird auf jedes Element der Eingangsserie angewendet, und der Ausgang wird in einem anderen Array gespeichert.

Binärer Betrieb: Dieser Vorgang wird auf jedes Element der ersten Eingangsserie und die entsprechende Komponente der zweiten Eingangsserie angewendet. Wie der UNRARY -Betrieb wird auch das Ergebnis im Ausgangsarray gespeichert.

Weder ein unärer Betrieb noch binärer Betrieb ändert direkt die als Parameter übergebene Komponente. Wenn der Ausgang dieselbe Serie angibt, werden sie indirekt vom Algorithmus verändert. Lassen Sie uns die Funktion STD :: Transformation und ihre Modi im Detail diskutieren.

Unary Operation:

STD :: Transformation bezieht die angegebene Funktion auf einen Bereich und speichert die Ausgabe in einem anderen Bereich. Diese Technik führt einen unären Betrieb in den Komponenten der Serie (Array, Array+12) aus und speichert dann die Ausgabe in der Serie, beginnend mit dem Ergebnis.

Das anschließende Programm zeigt, wie unarte Operationen in einem Array durchgeführt werden können. Die Transformation () -Funktion empfängt einen Zeiger auf die anfänglichen und endgültigen Positionen eines Arrays und die anfängliche Position des resultierenden Arrays.

#enthalten
#enthalten
Verwenden von Namespace STD;
int square (int m)
kehren m*m zurück;

int main (int lmn, char ** pqr)
Int Array [12] = 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26;
int Ergebnis [12];
Transformation (Array, Array+12, Ergebnis, Quadrat);
für (int j = 0; j<12; j++)
Cout <

Durch Einbeziehung der Bibliotheken werden wir das Programm starten. Header -Datei # include für Eingabe- und Ausgabezwecke. Daher wird die Header -Datei # include für die Transformation () -Funktion verwendet. Wir definieren den Datentyp -Ganzzahl für den Unary Operation. Außerdem definieren wir einen Ganzzahl -Datentyp zu seiner Variablen 'M'.

Darüber hinaus definieren wir die quadratische Funktion, indem wir das Quadrat der Variablen nehmen. Im Hauptteil erklären wir das Array. Wir nehmen 12 sogar Zahlen in das Array. Der Datentyp des Eingangsarrays und das resultierende Array ist ähnlich. Die Ausgabe wird in einem Neuarray gespeichert. Anschließend wenden wir die Funktion transform () an. Diese Funktion Iteratoren bis hin zu Start- und Endpositionen einer Serie. Die Serie verwendet (Array, Array+12), die alle Komponenten des Eingangsarrays enthält. Es enthält auch die Komponente, auf die das Array zeigt.

Hier ist das resultierende Array ein Ausgabe -Iterator und iteriert zum Beginn der Serie, in der die Ausgabe gespeichert wird. Die UNIARY -Funktion nimmt eine Komponente der Kategorie als Argument auf und gab dann einen Wert zurück, den das resultierende Array ändern kann. Der UNARARY -Betrieb gilt für die in (Array, Array+12) definierte Reihe (Array, Array+12). Dies wendet eine Methode für jede Komponente einer Serie an. Endlich verwenden wir für die Schleife. Jedes Element wird auf einer neuen Zeile gedruckt.

Binäroperation:

Diese Technik führt den binären Betrieb in den Komponenten der Serie (erstes Element, letztes Element) mit der Komponente in der zweiten Position in der Serie aus. Es spart das Ergebnis in der Serie, beginnend mit dem Ergebnis. Die Transformation () wendet eine Funktion an, die zwei Komponenten nimmt und zwei Parameter aus den Eingaberien für jedes Komponentenpaar empfängt. In diesem Programm führen wir Binärvorgänge für die angegebenen Daten aus. Wenn Komponenten aus zwei Arrays hinzugefügt werden müssen, verwenden wir die Binäroperatormethode.

#enthalten
#enthalten
#enthalten
Verwenden von Namespace 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:";
für (int k = 0; kCout <<" <
Cout <<'\n';
std :: Cout <<"Second array:";
für (int k = 0; kCout <<" <
Cout <<'\n';
STD :: Transformation (INP_arr1, INP_arr1+A, INP_arr2, OTP_arr, Operator_increment);
std :: Cout <<"Resultant array:";
für (int k = 0; k<8; k++)
Cout <<" << otp_arr[k];

Cout <<'\n';
Rückkehr 0;

In diesem Fall integrieren wir eine neue Header -Datei, die für STD :: Transformation verwendet wird, und eine andere Header -Datei #include wird für std :: vector verwendet. Jetzt wenden wir die binäre Funktion nach der Transformationsfunktion an. Wir deklarieren hier zwei Variablen 'K' und 'L', und es gibt die Hinzufügung der Variablen "K" in die Variable "l" zurück. Darüber hinaus definieren wir zwei verschiedene Arrays. In jedem Array gibt es 8 Elemente. Und um dies darzustellen, verwenden wir die Variable 'a'.

Der Datentyp der Arrays ist eine Ganzzahl. Die Ausgabe wird in einem Neuarray gespeichert, das durch 'otp_arr' dargestellt wird. Wir möchten den Text 'First Array' drucken; Daher verwenden wir die Cout -Funktion. Wir haben für das erste eingetragene Array eine Schleife beantragt. Auf diese Weise erhalten wir die Elemente des ersten Arrays. Wir wenden das Newline -Charakter '\ n' an.

Als nächstes verwenden wir erneut eine für Schleife, um das zweite Array zu erhalten. Der Hauptteil des Programms besteht darin, die Transformationsfunktion für diese Arrays anzuwenden. Diese Funktion übernimmt das erste und letzte Element des ersten Arrays, das erste Element des zweiten Arrays und das erste Element des resultierenden Arrays. Dann wird die binäre Funktion auf zwei Arrays angewendet. Die STD :: Transform () -Methode wendet einen Binäroperator auf jede Komponente im Bereich an und spart den Rückgabewert. Auf die gleiche Weise erhalten wir das resultierende Array. Wir haben uns auch für die resultierende Array beantragt.

Diese Funktion erhält auch den Beginn des Ausgangsarrays und einen Zeiger auf die Binärfunktion, die für die beiden definierten Arrays gilt. Die binäre Funktion akzeptiert zwei Komponenten (jeweils einer der beiden Serien) als Argumente. Und es gibt ein Array zurück, das in den Datentyp von OTP_arr umgewandelt wird.

Zugabe von zwei Vektoren:

Wir können die STD :: Transformationsfunktion verwenden, um die Zielserie ähnlich der Eingabeserie zu erstellen und eine Einstellung zu ändern. Das nachfolgende Beispiel zeigt, wie Binärübersetzungen verwendet werden können.

#enthalten
#enthalten
#enthalten
#enthalten
int op_increase (int j) return ++ j;
int main ()
STD :: VektorABC;
STD :: Vektorxyz;
für (int j = 1; j<8; j++)
ABC.push_back (j*20);
xyz.Größenänderung (ABC.Größe());
std :: Transformation (ABC.begin (), ABC.end (), xyz.begin (), op_increase);
std :: Transformation (ABC.begin (), ABC.end (), xyz.begin (), ABC.begin (), std :: plus());
std :: Cout <<"Output";
für (std :: vector:: iterator it = ABC.Start(); Es!= ABC.Ende(); ++ es)
std :: Cout <<" <<*it;
std :: Cout <<'\n';
Rückkehr 0;

Wenn das Programm beginnt, werden die Bibliotheken zuerst integriert. #Include Library wird auf die STD :: Transformationsfunktion angewendet. #Include gilt für die STD :: Vektorfunktion. #Include erzählt STD :: Plus -Methode. Die Funktion op_increase () wird für Konvertierungen angewendet, um die Bewertung der Parameter zu erhöhen.

Wir integrieren zwei Vektoren, und ihre Datentypen sind ähnlich. Nach der Deklaration für die Loop wenden wir die STD :: Transformationsfunktion an. Wir deklarieren 8 Elemente für Schleife. In der verwendeten Serie in der Funktion transform () ist (ABC) (ABC.Beginnen Sie, ABC.Ende), das alle Komponenten zwischen ABC enthält.Beginnen Sie und ABC.Ende. Hier xyz.Beginnen Sie Iteraten zum Startort der zweiten Serie. STD :: Plus () ist eine integrierte Funktion und wird in einer binären Umwandlung verwendet, um zwei Vektoren hinzuzufügen. Das Ergebnis des oben genannten Code sieht folgendermaßen aus:

Abschluss:

Dieser Artikel hat die STD :: Transformationsfunktion erläutert. Die Funktion wird auf zwei Arten verwendet. Eine unäre Funktion nimmt nur eine Komponente als Argument ein und gibt einen Wert zurück. Eine binäre Funktion, die zwei Komponenten (eine aus jeder der beiden Serien) als Argumente nimmt und dann einen resultierenden Wert zurückgibt. Der binäre Betrieb gilt immer für Paare von Komponenten in zwei Bereichen. Es bezieht die angegebene Funktion auf eine Serie und spart die Ausgabe in einer anderen Serie.