Примеры функций C++

Primery Funkcij C



Класс C++, который работает как функция, называется функтором. Для вызова функторов используется тот же старый синтаксис вызова функций. Мы создаем объект, который перегружает «operator()» для создания функтора. Мы также можем сказать, что объекты, которые можно интерпретировать либо как функцию, либо как указатель на функцию, называются функторами. При моделировании функциональных эффектов с использованием значений параметрических типов данных «фунторы» чрезвычайно удобны. В этой статье концепция функтора будет подробно изучена вместе с кодами C++.

Пример 1:

«iostream» — это заголовочный файл, который мы включаем сюда, поскольку нам нужно использовать функции, объявленные в этом заголовочном файле. Заголовочный файл «iostream» содержит объявление функции. Сюда также добавляется пространство имен «std». Затем мы создаем класс под названием «FunctorClass». Ниже мы вводим «public», который здесь является общедоступным конструктором, и помещаем функцию «operator()». Затем мы помещаем предложение, которое хотим отобразить на экране, в операторе «cout».

После этого мы вызываем функцию «main()», а затем создаем объект «FunctorClass» с именем «my_functor». Здесь мы вызываем функцию «my_functor()», чтобы она отображала оператор, который мы добавили под функцией «operator()».







Код 1:



#include
с использованием пространство имен стандартный ;
сорт ФункторКласс {
общественный :
пустота оператор ( ) ( ) {
расчет << «Здесь называется операция» ;
}
} ;
интервал основной ( ) {
FunctorClass my_functor ;
мой_функтор ( ) ;

возвращаться 0 ;
}

Выход:



Строка, которую мы добавили в функцию «operator()» класса «FunctorClass», отображается здесь с использованием объекта-функтора «my_functor».





Пример 2:

Мы включили сюда заголовочный файл «iostream», поскольку в заголовочном файле «iostream» содержится объявление некоторой функции. Также вставляется пространство имен «std». Далее мы создаем класс с именем «SquareClass».



Ниже мы вводим «public», который является общедоступным конструктором, и размещаем под ним функцию «operator()» типа данных «int». Мы передаем переменную «val» типа данных «int» в эту функцию «operator()». Эта функция возвращает результат умножения, поскольку мы вставили «val * val» в функцию «return()» ниже функции «operator()».

Теперь здесь вызывается функция «main()». Затем здесь создается объект с именем «s_functor» класса «SquareFunctor». Затем мы используем «cout», который помогает визуализировать информацию. После этого мы вызываем здесь объект «my_functor()» как функцию, и он возвращает результат умножения «5 * 5», поскольку мы добавили «5» в качестве параметра при его вызове.

Код 2:

#include
с использованием пространство имен стандартный ;
сорт Квадратный класс {
общественный :
интервал оператор ( ) ( интервал вал ) {
возвращаться ( вал * вал ) ;
}
} ;
интервал основной ( ) {
SquareClass s_functor ;
расчет << 'Квадрат заданного значения равен ' << конец ;
расчет << s_function ( 5 ) ;

возвращаться 0 ;
}

Выход:

Мы получаем результат после вызова объекта «my_functor» класса «SqaureClass», например функции «my_functor()», а затем передачи «5». Получаем «25» как квадрат числа «5».

Пример 3:

Сюда включен заголовочный файл «iostream», поскольку он содержит объявление функции, а после него добавляется пространство имен «std». Затем создается класс «ProductFunctor». Под ним вводится публичный конструктор «public», а под ним располагается функция «operator()» типа данных «int». Здесь мы переопределяем эту функцию и передаем в нее два параметра: «int var1» и «int var2».

Затем мы используем «возврат» ниже и умножаем обе переменные, которые возвращают результат умножения обоих чисел «var1 * var2». Затем здесь вызывается функция «main()», и мы генерируем объект класса с именем «P_functor» класса «ProductFunctor». Затем мы инициализируем новую переменную с именем «pro_result» и назначаем объект «P_functor» в качестве функции «P_functor()» после его вызова.

В качестве параметра мы передаем «28» и «63». Это умножит оба значения и сохранит результат в переменной «pro_result», которую мы печатаем ниже, используя «cout» и передавая в нее «pro_result».

Код 3:

#include
с использованием пространство имен стандартный ;
сорт ПродуктФунктор {
общественный :
интервал оператор ( ) ( интервал вар1, интервал вар2 ) {
возвращаться вар1 * вар2 ;
}
} ;
интервал основной ( ) {
ПродуктФунктор P_functor ;
интервал prod_result '=' P_функция ( 28 , 63 ) ;
расчет << «Продукт:» << prod_result << конец ;
возвращаться 0 ;
}

Выход:

Мы получаем продукт после вызова объекта «P_functor» как функции «P_functor()» и передачи ему значений. Произведение этих значений равно «1764».

Пример 4:

В этом экземпляре создается «GreetingFunctorClass». Затем мы вставляем «публичный» конструктор и переопределяем функцию «operator()» в этом «публичном» конструкторе. Набираем «Привет! Я здесь программист C++» после размещения «cout» под функцией «operator()».

Теперь и далее мы вызываем «main()». Здесь мы создаем «g_functor» как объект «GreetingFunctorClass», а затем вызываем этот объект «g_functor» как функцию «g_functor()». Это дает результат, который мы добавили в функцию «operator()» при ее переопределении.

Код 4:

#include
с использованием пространство имен стандартный ;
с использованием пространство имен стандартный ;
сорт ПриветствиеФункторКласс {
общественный :
пустота оператор ( ) ( ) {
расчет << «Привет! Я программист на C++» ;
}
} ;
интервал основной ( ) {
ПриветствиеFunctorКласс g_functor ;
g_function ( ) ;
возвращаться 0 ;
}

Выход:

Здесь мы можем заметить, что оператор, который мы добавили, когда переопределили функцию «operator()» в нашем коде, отображается здесь, когда мы вызываем объект класса как функцию.

Пример 5:

На этот раз включён файл «bits/stdc++.h», поскольку он содержит все необходимые объявления функций. Затем сюда помещается пространство имен «std». Класс, который мы здесь создаем, — это класс «incrementFunctor». Затем мы создаем «частный» конструктор и инициализируем переменную «int_num» типом данных «int».

Под этим «публичным» конструктором мы помещаем «incrementFunctor» и передаем внутрь него «int n1». Затем мы набираем «int_num(n1)» после размещения «:». Затем мы переопределяем функцию, которая является функцией «operator()» типа данных «int», и объявляем здесь «int arrOfNum». Затем мы используем «возврат» и вставляем «int_num + arrOfNum». Теперь это увеличивает значения «arrOfNum», добавляет к ним значение «int_num» и возвращает их сюда.

После вызова «main()» мы инициализируем «arrOfNum» и присваиваем здесь различные целочисленные значения. Затем инициализируется переменная «n1», куда мы добавляем функцию «sizeof», например «sizeof(arrOfNum)/sizeof(arrOfNum[0])». После этого «additionNumber» инициализируется цифрой «3». Теперь мы используем функцию «transform()». Этот «transform()» аналогичен созданию объекта класса «increamentFunctor» и последующему вызову его объекта. После этого мы используем цикл «for», а затем «cout» «arrOfNum[i]».

Код 5:

#include
с использованием пространство имен стандартный ;
сорт приращениеФунктор
{
частный :
интервал int_num ;
общественный :
приращениеФунктор ( интервал n1 ) : int_num ( n1 ) { }
интервал оператор ( ) ( интервал arrOfNum ) константа {
возвращаться int_num + arrOfNum ;
}
} ;
интервал основной ( )
{
интервал arrOfNum [ ] '=' { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
интервал n1 '=' размер ( arrOfNum ) / размер ( arrOfNum [ 0 ] ) ;
интервал дополнительный номер '=' 3 ;
трансформировать ( arrOfNum, arrOfNum + n1, arrOfNum, инкрементальный функтор ( дополнительный номер ) ) ;

для ( интервал я '=' 0 ; я < n1 ; я ++ )
расчет << arrOfNum [ я ] << ' ' ;
}

Выход:

Здесь показан результат выполнения кода, в котором «incrementFunctor» — это «Functor», который используется в качестве функции.

Пример 6:

В этом коде мы используем предопределенный «большой» функтор. Здесь мы включаем четыре разных заголовочных файла по мере необходимости в нашем коде, поскольку в них объявлены функции или методы, которые нам нужны в нашем коде. Затем, после добавления «std» и последующего вызова «main()», мы инициализируем вектор «myIntegerVector». Мы вставляем в этот вектор несколько неотсортированных значений. Ниже мы применяем функцию «сортировки» для сортировки этих векторных значений.

Когда мы используем эту функцию, она сортирует значения в порядке возрастания. Но здесь мы используем «большее» — предопределенную функцию в C++, которая дает результат сортировки по убыванию. После этого мы отображаем отсортированные значения с помощью цикла for и затем cout.

Код 6:

#include
#include <алгоритм>
#include <вектор>
#include <функционал>
с использованием пространство имен стандартный ;

интервал основной ( ) {
вектор < интервал > мойIntegerVector '=' { 13 , двадцать один , 19 , 44 , 32 , 42 , 9 , 6 } ;
Сортировать ( мойЦелыйВектор. начинать ( ) , мойЦелыйВектор. конец ( ) , больший < интервал > ( ) ) ;
для ( интервал vec_num : мойIntegerVector ) {
расчет << vec_num << '' ;
}
возвращаться 0 ;
}

Выход:

Все значения вектора сортируются по убыванию с помощью заранее определенного функтора в C++, который является «большим» функтором, и его определение доступно в «функциональном» заголовочном файле.

Заключение

В этой статье подробно рассматривается концепция «функтора C++». Мы изучили, что объект можно вызвать как функцию для перегрузки функции под названием «operator()». Это известно как функтор. Публичный доступ должен быть предоставлен для того, чтобы перегрузка «operator()» использовалась по назначению. Мы проиллюстрировали различные примеры использования «функторов» и предопределенных «функторов» в нашем коде.