Функция Std::transform существует в C++ STL. Мы должны включить заголовочный файл , чтобы использовать эту функцию. Этот метод используется для выполнения операции на всех компонентах. Он последовательно применяет операции к одному или нескольким компонентам массива и сохраняет выходные данные в результирующем массиве. Этот подход работает двумя способами. Эти:
Унарная операция: применяется к каждому элементу входной серии, а выходные данные сохраняются в другом массиве.
Двоичная операция: эта операция применяется к каждому элементу первой входной серии и соответствующему компоненту второй входной серии. Как и унарная операция, результат также сохраняется в выходном массиве.
Ни унарная операция, ни бинарная операция напрямую не изменяют компонент, переданный в качестве параметра. Если в выходных данных указаны одни и те же серии, они косвенно изменяются алгоритмом. Давайте подробно обсудим функцию std::transform и ее режимы.
Унарная операция
Std::transform связывает указанную функцию с одним диапазоном и сохраняет вывод в другом диапазоне. Этот метод выполняет унарную операцию над компонентами в ряду (массив, массив+12), а затем сохраняет вывод в ряду, начиная с результата.
Следующая программа показывает, как выполнять унарные операции над массивом. Функция transform() получает указатель на начальную и конечную позиции массива и начальную позицию результирующего массива.
#include <iostream>
#include <algorithm>
using namespace 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 result[12];
transform(array, array+12, result, square);
for(int j = 0; j<12; j++) {
cout <<result[j] <<«\n«;
}
}
Включив библиотеки, мы собираемся запустить программу. Заголовочный файл # include предназначен для ввода и вывода. Поэтому файл заголовка # include используется для функции transform(). Мы определяем тип данных integer для унарной операции. Кроме того, мы определяем целочисленный тип данных для его переменной ’m’.
Кроме того, мы определяем функцию квадрата, взяв квадрат переменной. В основном теле мы объявляем массив. Мы берем 12 четных чисел в массиве. Тип данных входного массива и результирующего массива аналогичны. Результат сохраняется в новом массиве. Затем мы применяем функцию transform(). Эта функция итерирует начальную и конечную позиции ряда. В серии используется (массив, массив+12), который включает все компоненты входного массива. Он также содержит компонент, на который указывает массив.
Здесь результирующий массив является выходным итератором, и он выполняет итерацию до начала серии, в которой хранятся выходные данные. Унарная функция принимает компонент категории, указывающий на массив, в качестве аргумента, а затем возвращает значение, которое результирующий массив может изменить. Унарная операция применяется к серии, определенной в (массив, массив+12). Это применяет метод к каждому компоненту ряда. Наконец, мы используем цикл for. Каждый элемент печатается с новой строки.
Бинарная операция
Этот метод выполняет бинарную операцию над компонентами в ряду (первый элемент, последний элемент) с компонентом, присутствующим во второй позиции в ряду. Сохраняет результат в серии, начиная с результата. Функция transform() применяет функцию, которая принимает два компонента и получает два параметра из входного ряда для каждой пары компонентов. В этой программе мы выполняем бинарные операции над указанными данными. Если есть необходимость добавить компоненты из двух массивов, используем метод бинарного оператора.
#include <iostream>
#include <algorithm>
#include <vector>
using 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:»;
for(int k=0; k<a; k++){
cout <<‘ ‘ <<inp_arr1[k];
}
cout <<‘\n‘;
std::cout <<«Second array:»;
for(int k=0; k<a; k++){
cout <<‘ ‘ <<inp_arr2[k];
}
cout <<‘\n‘;
std::transform (inp_arr1, inp_arr1+a, inp_arr2, otp_arr, operator_increment);
std::cout <<«Resultant array:»;
for(int k=0; k<8; k++){
cout <<‘ ‘ << otp_arr[k];
}
cout <<‘\n‘;
return 0;
}
В этом случае мы интегрируем новый заголовочный файл, который используется для std::transform, а другой заголовочный файл #include используется для std::vector. Теперь мы применяем бинарную функцию с помощью функции преобразования. Здесь мы объявляем две переменные «k» и «l», и он возвращает добавление переменной «k» к переменной «l». Далее мы определяем два разных массива. В каждом массиве 8 элементов. И чтобы представить это, мы используем переменную ’a’.
Тип данных массивов — целое число. Вывод сохраняется в новом массиве, который представлен ’otp_arr’. Мы хотим напечатать текст «первый массив»; поэтому мы используем функцию cout. Мы применили цикл для первого введенного массива. Таким образом, мы получаем элементы первого массива. Мы применяем символ новой строки ’\n’.
Затем мы снова используем цикл for для получения второго массива. Основная часть программы заключается в применении функции преобразования для этих массивов. Эта функция принимает первый и последний элементы первого массива, первый элемент второго массива и первый элемент результирующего массива. Затем бинарная функция применяется к двум массивам. Метод std::transform() применяет бинарный оператор к каждому компоненту в диапазоне и сохраняет возвращаемое значение. Таким же образом получаем результирующий массив. Мы также применили цикл для результирующего массива.
Эта функция также получает начало выходного массива и указатель на двоичную функцию, которая применяется к двум определенным массивам. Бинарная функция принимает два компонента (по одному из каждого из двух рядов соответственно) в качестве аргументов. И он возвращает массив, преобразованный в тип данных otp_arr.
Сложение двух векторов
Мы можем использовать функцию std::transform, чтобы сделать целевую серию похожей на входную серию и выполнить изменение на месте. В следующем примере показано, как использовать двоичные переводы.
#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>
int op_increase (int j) { return ++j; }
int main () {
std::vector<int>abc;
std::vector<int>xyz;
for (int j=1; j<8; j++)
abc.push_back (j*20);
xyz.resize(abc.size());
std::transform (abc.begin(), abc.end(), xyz.begin(), op_increase);
std::transform (abc.begin(), abc.end(), xyz.begin(), abc.begin(), std::plus<int>());
std::cout <<«Output»;
for (std::vector<int>::iterator it=abc.begin(); it!=abc.end(); ++it)
std::cout <<‘ ‘ <<*it;
std::cout <<‘\n‘;
return 0;
}
При запуске программы сначала будут интегрированы библиотеки. Библиотека #include применяется к функции std::transform. #include применяется к функции std::vector. Также #include связывает метод std::plus. Функция op_increase() применяется для преобразований, чтобы увеличить оценку параметров.
Мы интегрируем два вектора, и их типы данных похожи. После объявления цикла for мы применяем функцию std::transform. Мы объявляем 8 элементов в цикле for. В функции transform() используется последовательность (abc.begin, abc.end), которая включает все компоненты между abc.begin и abc.end. Здесь xyz.begin выполняет итерацию к начальному местоположению второй серии. Std::plus() — это встроенная функция, которая используется при двоичном преобразовании для сложения двух векторов. Результат вышеупомянутого кода выглядит следующим образом:
Заключение
В этой статье объясняется функция std::transform. Функция используется двумя способами. Унарная функция принимает в качестве аргумента только один компонент и возвращает значение. Бинарная функция, которая принимает два компонента (по одному из каждого из двух рядов) в качестве аргументов, а затем возвращает результирующее значение. Бинарная операция всегда применяется к парам компонентов в двух диапазонах. Он связывает указанную функцию с серией и сохраняет вывод в другой серии.
