Transformée C ++ STD

STD :: La fonction de transformation existe dans C ++ STL. Nous devons englober le fichier d'en-tête pour utiliser cette fonction. Cette méthode est utilisée pour effectuer une opération sur tous les composants. Il applique des opérations à un ou plusieurs composants du tableau en séquence et enregistre la sortie dans le tableau qui en résulte. Cette approche fonctionne de deux manières. Ceux-ci sont:

Opération unaire: Ceci est appliqué à chaque élément de la série d'entrée, et la sortie est stockée dans un autre tableau.

Opération binaire: Cette opération est appliquée à chaque élément de la première série d'entrée et au composant correspondant de la deuxième série d'entrée. Comme l'opération unaire, le résultat est également enregistré dans le tableau de sortie.

Ni l'opération unaire ni l'opération binaire ne modifie directement le composant passé comme un paramètre. Si la sortie spécifie la même série, elles sont modifiées indirectement par l'algorithme. Discutons de la fonction STD :: Transformer et de ses modes en détail.

Fonctionnement unaire:

STD :: Transform relie la fonction spécifiée en une seule plage et enregistre la sortie dans une autre plage. Cette technique exécute une opération unaire sur les composants de la série (tableau, tableau + 12), puis enregistre la sortie de la série à commencer par le résultat.

Le programme ultérieur montre comment effectuer des opérations unaires sur un tableau. La fonction transform () reçoit un pointeur vers les positions initiales et finales d'un tableau et la position initiale du tableau résultant.

#inclure
#inclure
Utilisation de Namespace Std;
int square (int m)
retour m * m;

int main (int lmn, char ** pqr)
Int Array [12] = 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26;
Résultat int [12];
transformée (tableau, tableau + 12, résultat, carré);
pour (int j = 0; j<12; j++)
couter <

En incluant les bibliothèques, nous allons démarrer le programme. Le fichier d'en-tête # inclut est à des fins d'entrée et de sortie. Par conséquent, le fichier d'en-tête # inclut est utilisé pour la fonction transform (). Nous définissons l'entier de type de données à l'opération unaire. De plus, nous définissons un type de données entier à sa variable «M».

De plus, nous définissons la fonction carrée en prenant le carré de la variable. Dans le corps principal, nous déclarons le tableau. Nous prenons 12 numéros même dans le tableau. Le type de données du tableau d'entrée et du tableau résultant est similaire. La sortie est enregistrée dans un nouveau tableau. Par la suite, nous appliquons la fonction transform (). Cette fonction itérateurs aux positions de départ et de fin d'une série. La série utilise (tableau, tableau + 12), qui comprend toutes les composantes du tableau d'entrée. Il contient également le composant que le tableau pointe vers.

Ici, le tableau résultant est un itérateur de sortie, et il itère au début de la série où la sortie est stockée. La fonction unaire prend une composante de la catégorie pointée vers le tableau comme argument, puis a rendu une valeur que le tableau résulte peut modifier. L'opération unaire s'applique à la série définie dans (tableau, tableau + 12). Cela applique une méthode à chaque composant d'une série. Enfin, nous utilisons pour Loop. Chaque élément est imprimé sur une nouvelle ligne.

Fonctionnement binaire:

Cette technique effectue le fonctionnement binaire sur les composants de la série (premier élément, dernier élément) avec le composant présent dans la deuxième position de la série. Il enregistre le résultat dans la série, en commençant par le résultat. Le transform () applique une fonction qui prend deux composants et reçoit deux paramètres de la série d'entrée pour chaque paire de composants. Dans ce programme, nous exécutons des opérations binaires sur les données spécifiées. S'il est nécessaire d'ajouter des composants de deux tableaux, nous utilisons la méthode de l'opérateur binaire.

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int opérator_increment (int k, int l)
retour 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:";
pour (int k = 0; kcouter <<" <
couter <<'\n';
std :: cout <<"Second array:";
pour (int k = 0; kcouter <<" <
couter <<'\n';
std :: transform (inp_arr1, inp_arr1 + a, inp_arr2, otp_arr, operator_increment);
std :: cout <<"Resultant array:";
pour (int k = 0; k<8; k++)
couter <<" << otp_arr[k];

couter <<'\n';
retour 0;

Dans ce cas, nous intégrons un nouveau fichier d'en-tête qui est utilisé pour STD :: Transform et un autre fichier d'en-tête #include est utilisé pour STD :: Vector. Maintenant, nous appliquons la fonction binaire par la fonction de transformation. Nous déclarons deux variables «k» et «l» ici, et il renvoie l'ajout de la variable «k» dans la variable «l». De plus, nous définissons deux tableaux différents. Il y a 8 éléments dans chaque tableau. Et pour représenter cela, nous utilisons la variable «A».

Le type de données des tableaux est un entier. La sortie est stockée dans un nouveau tableau qui est représenté par «OTP_ARR». Nous voulons imprimer le texte «premier tableau»; Par conséquent, nous utilisons la fonction cout. Nous avons demandé une boucle pour le premier tableau entré. Par là, nous obtenons les éléments du premier tableau. Nous appliquons le caractère Newline '\ n'.

Ensuite, nous utilisons à nouveau une boucle pour obtenir le deuxième tableau. La partie principale du programme est d'appliquer la fonction de transformation de ces tableaux. Cette fonction prend le premier et le dernier élément du premier tableau, le premier élément du deuxième tableau et le premier élément du tableau résultant. Ensuite, la fonction binaire est appliquée à deux tableaux. La méthode std :: transform () applique un opérateur binaire à chaque composant de la plage et enregistre la valeur de retour. De la même manière, nous obtenons le tableau qui en résulte. Nous avons également demandé une boucle pour le tableau qui en résulte.

Cette fonction obtient également le début du tableau de sortie et un pointeur vers la fonction binaire, qui s'applique aux deux tableaux définis. La fonction binaire accepte deux composantes (une de chacune des deux séries, respectivement) comme arguments. Et il renvoie un tableau transformé en type de données d'OTP_ARR.

Ajout de deux vecteurs:

Nous pouvons utiliser la fonction STD :: Transform pour rendre la série cible similaire à la série d'entrée et effectuer une altération en place. L'exemple suivant montre comment utiliser des traductions binaires.

#inclure
#inclure
#inclure
#inclure
int op_inCrease (int j) return ++ j;
int main ()
STD :: Vectorabc;
STD :: Vectorxyz;
pour (int j = 1; j<8; j++)
abc.push_back (j * 20);
xyz.redimensionner (ABC.taille());
Std :: Transform (ABC.begin (), ABC.end (), xyz.begin (), op_increase);
Std :: Transform (ABC.begin (), ABC.end (), xyz.begin (), ABC.begin (), std :: Plus());
std :: cout <<"Output";
pour (STD :: Vector:: iterator it = ABC.commencer(); il!= ABC.fin(); ++ it)
std :: cout <<" <<*it;
std :: cout <<'\n';
retour 0;

Lorsque le programme commencera, les bibliothèques seront d'abord intégrées. #include La bibliothèque est appliquée à la fonction STD :: Transformer. #include s'applique à la fonction vectorielle std ::. #include raconte la méthode std :: Plus. La fonction op_increase () est appliquée pour les conversions pour incrémenter l'évaluation des paramètres.

Nous intégrons deux vecteurs, et leurs types de données sont similaires. Après avoir déclaré pour Loop, nous appliquons la fonction STD :: Transformer. Nous déclarons 8 éléments pour Loop. Dans la fonction transform () la série utilisée est (ABC.commencer, ABC.fin), qui comprend tous les composants entre ABC.commencer et ABC.fin. Ici xyz.Commencer les itérations jusqu'à l'emplacement de départ de la deuxième série. STD :: Plus () est une fonction intégrée et est utilisée dans une conversion binaire pour ajouter deux vecteurs. Le résultat du code susmentionné ressemble à ceci:

Conclusion:

Cet article a expliqué la fonction std :: transform. La fonction est utilisée de deux manières. Une fonction unaire ne prend qu'un seul composant comme argument et rend une valeur. Une fonction binaire qui prend deux composantes (une de chacune des deux séries) comme arguments, puis il renvoie une valeur résultante. L'opération binaire s'applique toujours aux couples de composants dans deux plages. Il relie la fonction spécifiée à une série et enregistre la sortie dans une autre série.