Пример 1:
„iostream“ е заглавният файл, който включваме тук, защото трябва да използваме функциите, които са декларирани в този заглавен файл. Заглавният файл 'iostream' съдържа декларация на функция. Пространството от имена „std“ също се добавя тук. След това генерираме клас, наречен „FunctorClass“. Под това въвеждаме „public“, което е публичният конструктор тук, и поставяме функцията „operator()“. След това поставяме изречение, което искаме да изобразим на екрана, в оператора „cout“.
След това извикваме функцията “main()” и след това създаваме обекта на “FunctorClass” с името “my_functor”. Тук извикваме функцията “my_functor()”, така че тя показва израза, който добавихме под функцията “operator()”.
Код 1:
#include
използвайки пространство от имена std ;
клас FunctorClass {
публичен :
невалиден оператор ( ) ( ) {
cout << „Операцията се нарича тук“ ;
}
} ;
вътр основен ( ) {
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използвайки пространство от имена std ;
клас SquareClass {
публичен :
вътр оператор ( ) ( вътр вал ) {
връщане ( вал * вал ) ;
}
} ;
вътр основен ( ) {
SquareClass s_функтор ;
cout << 'Квадратът на дадената стойност е ' << endl ;
cout << s_функция ( 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използвайки пространство от имена std ;
клас ProductFunctor {
публичен :
вътр оператор ( ) ( вътр var1, вътр var2 ) {
връщане var1 * var2 ;
}
} ;
вътр основен ( ) {
ProductFunctor P_функтор ;
вътр продукт_резултат = P_функция ( 28 , 63 ) ;
cout << 'Продуктът е: ' << продукт_резултат << endl ;
връщане 0 ;
}
Изход:
Получаваме продукта, след като извикаме обекта „P_functor“ като функция „P_functor()“ и му предадем стойностите. Произведението на тези стойности е „1764“.
Пример 4:
В този случай се генерира „GreetingFunctorClass“. След това вмъкваме „публичния“ конструктор и заместваме функцията „operator()“ в този „публичен“ конструктор. Пишем „Здравей! Тук съм C++ програмист“, след като поставите „cout“ под функцията „operator()“.
Сега нататък извикваме „main()“. Създаваме „g_functor“ тук като обект на „GreetingFunctorClass“ и след това извикваме този обект „g_functor“ като функцията „g_functor()“. Това дава резултата, който добавихме във функцията „operator()“, докато я заменяме.
Код 4:
#includeизползвайки пространство от имена std ;
използвайки пространство от имена std ;
клас Поздрав FunctorClass {
публичен :
невалиден оператор ( ) ( ) {
cout << „Здравейте! Тук съм програмист на C++“ ;
}
} ;
вътр основен ( ) {
Поздрав FunctorClass g_функтор ;
g_функция ( ) ;
връщане 0 ;
}
Изход:
Тук може да забележим, че операторът, който добавихме, когато отменихме функцията „operator()“ в нашия код, се показва тук, докато извикваме обекта на класа като функция.
Пример 5:
“bits/stdc++.h” е включен този път, тъй като съдържа всички необходими декларации на функции. След това пространството от имена „std“ се поставя тук. Класът, който създаваме тук, е класът „incrementFunctor“. След това създаваме „частен“ конструктор и инициализираме променливата „int_num“ с типа данни „int“.
Под този, „публичния“ конструктор, поставяме „incrementFunctor“ и предаваме „int n1“ вътре в него. След това въвеждаме „int_num(n1)“ след поставяне на „:“. След това заместваме функцията, която е функцията „operator()“ от типа данни „int“ и декларираме „int arrOfNum“ тук. След това използваме „return“ и вмъкваме „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използвайки пространство от имена std ;
клас инкрементФункт
{
частен :
вътр 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 ; аз ++ )
cout << arrOfNum [ аз ] << ' ' ;
}
Изход:
Резултатът от кода е показан тук, в който „incrementFunctor“ е „функторът“, който се използва като функция.
Пример 6:
В този код използваме предварително дефинирания „по-голям“ функтор. Тук включваме четири различни заглавни файла, тъй като ги изискваме в нашия код, защото функциите или методите, от които се нуждаем в нашия код, са декларирани в тях. След това, след като добавим „std“ и след това извикаме „main()“, ние инициализираме вектора „myIntegerVector“. Вмъкваме някои несортирани стойности в този вектор. Под това прилагаме функцията „сортиране“, за да сортираме тези векторни стойности.
Когато използваме тази функция, тя сортира стойностите във възходящ ред. Но ние използваме „по-голямото“ тук, което е предварително дефинираната функция в C++, която дава резултат от сортиране по низходящ начин. След това показваме сортираните стойности с помощта на цикъл „for“ и след това „cout“.
Код 6:
#include#include <алгоритъм>
#include <вектор>
#include <функционален>
използвайки пространство от имена std ;
вътр основен ( ) {
вектор < вътр > myIntegerVector = { 13 , двадесет и едно , 19 , 44 , 32 , 42 , 9 , 6 } ;
вид ( myIntegerVector. започвам ( ) , myIntegerVector. край ( ) , по-голяма < вътр > ( ) ) ;
за ( вътр vec_num : myIntegerVector ) {
cout << vec_num << '' ;
}
връщане 0 ;
}
Изход:
Всички стойности на вектора са сортирани по низходящ начин с помощта на предварително дефинирания функтор в C++, който е „по-големият“ функтор и неговата дефиниция е достъпна във „функционалния“ заглавен файл.
Заключение
Концепцията за „функтор C++“ е подробно проучена в тази статия. Проучихме, че даден обект може да бъде извикан като функция за претоварване на функция, наречена 'operator()'. Това е известно като функтор. Трябва да се осигури публичен достъп, за да може претоварването на „operator()“ да се използва по предназначение. Ние илюстрирахме различни примери, в които използвахме „функторите“ и предварително дефинирания „функтор“ в нашия код.