C ++ STD Transform

Std :: La funzione di trasformazione esiste in C ++ STL. Dobbiamo racchiudere il file di intestazione per utilizzare questa funzione. Questo metodo viene utilizzato per eseguire un'operazione su tutti i componenti. Applica le operazioni a uno o più componenti di array in sequenza e salva l'output nell'array risultante. Questo approccio funziona in due modi. Questi sono:

Operazione unaria: Questo viene applicato a ogni elemento della serie di input e l'output è archiviato in un altro array.

Operazione binaria: Questa operazione viene applicata a ogni elemento della prima serie di input e al componente corrispondente della seconda serie di input. Come l'operazione unaria, il risultato viene anche salvato nell'array di output.

Né operazioni uniche né operazioni binarie modificano direttamente il componente passato come parametro. Se l'output specifica la stessa serie, sono modificati indirettamente dall'algoritmo. Discutiamo in dettaglio la funzione std :: trasforma e le sue modalità.

Operazione unaria:

Std :: trasformazione mette in relazione la funzione specificata con un intervallo e salva l'output in un altro intervallo. Questa tecnica esegue un'operazione unaria sui componenti della serie (array, array+12) e quindi salva l'output nella serie a partire dal risultato.

Il programma successivo mostra come eseguire operazioni uniche su un array. La funzione trasform () riceve un puntatore alle posizioni iniziali e finali di un array e alla posizione iniziale dell'array risultante.

#includere
#includere
Utilizzo dello spazio dei nomi std;
int quadrato (int m)
restituire m*m;

int main (int lmn, char ** pqr)
Int Array [12] = 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26;
int risultato [12];
trasformazione (array, array+12, risultato, quadrato);
per (int j = 0; j<12; j++)
cout <

Includendo le biblioteche, inizieremo il programma. Il file di intestazione # include è per scopi di input e output. Pertanto, il file di intestazione # include viene utilizzato per la funzione trasform (). Definiamo il numero intero del tipo di dati all'operazione unaria. Inoltre, definiamo un tipo di dati interi alla sua variabile 'M'.

Inoltre, definiamo la funzione quadrata prendendo il quadrato della variabile. Nel corpo principale, dichiariamo l'array. Prendiamo 12 numeri pari nell'array. Il tipo di dati dell'array di input e l'array risultante è simile. L'output viene salvato in un nuovo array. Successivamente, applichiamo la funzione trasform (). Questa funzione iteratrici alle posizioni di inizio e fine di una serie. La serie utilizza (array, array+12), che include tutti i componenti dell'array di input. Contiene anche il componente a cui l'array punta.

Qui l'array risultante è un iteratore di output e si ITERA all'inizio della serie in cui viene memorizzata l'output. La funzione unaria prende un componente della categoria puntato all'array come argomento e quindi ha restituito un valore che l'array risultante può alterare. L'operazione unaria si applica alla serie definita in (array, array+12). Questo applica un metodo per ogni componente di una serie. Finalmente, usiamo per loop. Ogni elemento è stampato su una nuova linea.

Operazione binaria:

Questa tecnica esegue l'operazione binaria sui componenti della serie (primo elemento, ultimo elemento) con il componente presente nella seconda posizione nella serie. Salva il risultato nella serie, a partire dal risultato. Transform () applica una funzione che prende due componenti e riceve due parametri dalla serie di input per ogni coppia di componenti. In questo programma, eseguiamo operazioni binarie sui dati specificati. Se è necessario aggiungere componenti da due array, utilizziamo il metodo dell'operatore binario.

#includere
#includere
#includere
Utilizzo dello spazio dei nomi std;
int operator_increment (int k, int l)
restituire 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:";
per (int k = 0; kcout <<" <
cout <<'\n';
std :: cout <<"Second array:";
per (int k = 0; kcout <<" <
cout <<'\n';
std :: trasform (inp_arr1, inp_arr1+a, inp_arr2, otp_arr, operator_increment);
std :: cout <<"Resultant array:";
per (int k = 0; k<8; k++)
cout <<" << otp_arr[k];

cout <<'\n';
restituzione 0;

In questo caso, integriamo un nuovo file di intestazione utilizzato per STD :: Transform e un altro file di intestazione #Include viene utilizzato per std :: vector. Ora applichiamo la funzione binaria mediante la funzione di trasformazione. Dichiariamo due variabili "k" e "l" qui, e restituisce l'aggiunta della variabile "k" nella variabile "L". Inoltre, definiamo due array diversi. Ci sono 8 elementi in ogni array. E per rappresentare questo, utilizziamo la variabile 'A'.

Il tipo di dati degli array è un numero intero. L'output è archiviato in un nuovo array che è rappresentato da "OTP_ARR". Vogliamo stampare il testo "primo array"; Quindi usiamo la funzione cout. Abbiamo fatto domanda per loop per il primo array immesso. Con questo, otteniamo gli elementi del primo array. Applichiamo il carattere di Newline '\ n'.

Successivamente, usiamo di nuovo un loop per ottenere il secondo array. La parte principale del programma è applicare la funzione di trasformazione per questi array. Questa funzione prende il primo e l'ultimo elemento del primo array, il primo elemento del secondo array e il primo elemento dell'array risultante. Quindi la funzione binaria viene applicata a due array. Il metodo STD :: Transform () applica un operatore binario a ogni componente nell'intervallo e salva il valore di ritorno. Allo stesso modo, otteniamo l'array risultante. Abbiamo anche fatto domanda per il ciclo per l'array risultante.

Questa funzione ottiene anche l'inizio dell'array di output e un puntatore alla funzione binaria, che si applica ai due array definiti. La funzione binaria accetta due componenti (uno da ciascuna delle due serie, rispettivamente) come argomenti. E restituisce un array trasformato nel tipo di dati di OTP_ARR.

Aggiunta di due vettori:

Possiamo utilizzare la funzione STD :: Transform per rendere la serie di destinazione simile alla serie di input ed eseguire un'alterazione sul posto. L'esempio successivo dimostra come utilizzare le traduzioni binarie.

#includere
#includere
#includere
#includere
int op_increase (int j) return ++ j;
int main ()
Std :: VectorABC;
Std :: Vectorxyz;
per (int j = 1; j<8; j++)
ABC.push_back (j*20);
XYZ.Ridimensiona (ABC.misurare());
std :: trasforma (ABC.inizio (), ABC.end (), xyz.inizio (), op_increase);
std :: trasforma (ABC.inizio (), ABC.end (), xyz.inizio (), ABC.inizio (), std :: plus());
std :: cout <<"Output";
per (std :: vector:: iterator IT = ABC.inizio(); Esso!= ABC.FINE(); ++ esso)
std :: cout <<" <<*it;
std :: cout <<'\n';
restituzione 0;

Quando il programma inizia, prima le librerie saranno integrate. La libreria #include viene applicata alla funzione di trasformazione std ::. #include si applica alla funzione vettoriale std ::. #include mette in relazione std :: plus metodo. La funzione op_increase () viene applicata per le conversioni per incrementare la valutazione dei parametri.

Integriamo due vettori e i loro tipi di dati sono simili. Dopo aver dichiarato per loop, applichiamo la funzione di trasformazione std ::. Dichiariamo 8 elementi per loop. Nella funzione trasform () la serie utilizzata è (ABC.Inizia, ABC.fine), che include tutti i componenti tra ABC.Inizia e ABC.FINE. Qui XYZ.Inizia iterate nella posizione iniziale della seconda serie. Std :: plus () è una funzione integrata ed è utilizzata in una conversione binaria per aggiungere due vettori. Il risultato del codice sopra menzionato sembra questo:

Conclusione:

Questo articolo ha spiegato la funzione STD :: Transform. La funzione è utilizzata in due modi. Una funzione unaria prende solo un componente come argomento e restituisce un valore. Una funzione binaria che prende due componenti (uno da ciascuna delle due serie) come argomenti, quindi restituisce un valore risultante. L'operazione binaria si applica sempre alle coppie di componenti in due gamme. Racconta la funzione specificata in una serie e salva l'output in un'altra serie.