Пример 1:
„иостреам“ је датотека заглавља коју овде укључујемо јер морамо да користимо функције које су декларисане у овој датотеци заглавља. Датотека заглавља „иостреам“ садржи декларацију функције. Именски простор „стд“ је такође додат овде. Затим генеришемо класу под називом „ФунцторЦласс“. Испод овога уписујемо „публиц“ који је јавни конструктор овде и постављамо функцију „оператор()“. Затим постављамо реченицу коју желимо да прикажемо на екрану у изјави „цоут“.
После овога, позивамо функцију „маин()“, а затим креирамо објекат „ФунцторЦласс“ са именом „ми_фунцтор“. Овде зовемо функцију „ми_фунцтор()“ тако да она приказује изјаву коју смо додали испод функције „оператор()“.
Код 1:
#инцлуде <иостреам>
Користећи именског простора стд ;
класа ФунцторЦласс {
јавности :
празнина оператер ( ) ( ) {
цоут << 'Операција се зове овде' ;
}
} ;
инт главни ( ) {
ФунцторЦласс ми_фунцтор ;
ми_фунцтор ( ) ;
повратак 0 ;
}
Излаз:
Линија коју смо додали у функцију „оператор()“ функције „ФунцторЦласс“ је приказана овде коришћењем функторског објекта „ми_фунцтор“.
Пример 2:
Овде укључујемо датотеку заглавља „иостреам“ јер је нека декларација функције садржана у датотеци заглавља „иостреам“. Именски простор „стд“ је такође уметнут. Затим креирамо класу под називом „СкуареЦласс“.
Испод тога уписујемо „публиц“ који је јавни конструктор и позиционирамо функцију „оператор()“ типа података „инт“ испод њега. Ми прослеђујемо променљиву „вал“ типа података „инт“ овој функцији „оператор()“. Ова функција враћа резултат множења пошто смо убацили „вал * вал“ у функцију „ретурн()“ испод функције „оператор()“.
Сада се овде позива функција „маин()“. Затим се овде креира објекат са именом „с_фунцтор“ класе „СкуареФунцтор“. Затим користимо „цоут“ који помаже у приказивању информација. После овога, овде зовемо објекат „ми_фунцтор()” као функцију и он враћа резултат множења „5 * 5” пошто смо додали „5” као параметар док смо га позвали.
Код 2:
#инцлуде <иостреам>Користећи именског простора стд ;
класа СкуареЦласс {
јавности :
инт оператер ( ) ( инт вал ) {
повратак ( вал * вал ) ;
}
} ;
инт главни ( ) {
СкуареЦласс с_фунцтор ;
цоут << 'Квадрат дате вредности је' << ендл ;
цоут << с_фунцтион ( 5 ) ;
повратак 0 ;
}
Излаз:
Добијамо излаз након што позовемо објекат „ми_фунцтор“ класе „СкауреЦласс“ као што је функција „ми_фунцтор()“, а затим проследимо „5“. Добијамо „25“ као квадрат броја „5“.
Пример 3:
Датотека заглавља „иостреам“ је овде укључена јер садржи декларацију функције, а „стд“ именски простор се уводи касније. Затим се прави класа „ПродуцтФунцтор“. Јавни конструктор, „публиц“, је откуцан испод њега, а функција „оператор()“ типа података „инт“ је позиционирана испод њега. Овде надјачавамо ову функцију и у њу преносимо два параметра: „инт вар1“ и „инт вар2“.
Затим користимо „повратак“ испод овога и множимо обе променљиве које враћају резултат множења оба броја „вар1 * вар2“. Затим се овде позива функција „маин()“ и генеришемо објекат класе са именом „П_фунцтор“ класе „ПродуцтФунцтор“. Затим иницијализујемо нову променљиву са именом „про_ресулт“ и додељујемо објекат „П_фунцтор“ као функцију „П_фунцтор()“ након што је позовемо.
Продајемо „28“ и „63“ као параметар. Ово ће помножити обе вредности и сачувати резултат у променљивој „про_ресулт“ коју штампамо испод ове користећи „цоут“ и прослеђујући „про_ресулт“ у њу.
Код 3:
#инцлуде <иостреам>Користећи именског простора стд ;
класа ПродуцтФунцтор {
јавности :
инт оператер ( ) ( инт вар1, инт вар2 ) {
повратак вар1 * вар2 ;
}
} ;
инт главни ( ) {
ПродуцтФунцтор П_фунцтор ;
инт прод_ресулт = П_функција ( 28 , 63 ) ;
цоут << 'Производ је: ' << прод_ресулт << ендл ;
повратак 0 ;
}
Излаз:
Добијамо производ након што позовемо објекат „П_фунцтор“ као функцију „П_фунцтор()“ и проследимо му вредности. Производ тих вредности је „1764“.
Пример 4:
У овој инстанци се генерише „ГреетингФунцторЦласс“. Затим убацујемо „јавни“ конструктор и замењујемо функцију „оператор()“ у овом „јавном“ конструктору. Укуцамо „Здраво! Ја сам Ц++ програмер овде“ након што сам ставио „цоут“ испод функције „оператор()“.
Сада надаље, зовемо „маин()“. Овде креирамо „г_фунцтор“ као објекат „ГреетингФунцторЦласс“, а затим позивамо овај објекат „г_фунцтор“ као функцију „г_фунцтор()“. Ово даје резултат који смо додали у функцију „оператор()“ док смо је надјачали.
Код 4:
#инцлуде <иостреам>Користећи именског простора стд ;
Користећи именског простора стд ;
класа ГреетингФунцторЦласс {
јавности :
празнина оператер ( ) ( ) {
цоут << 'Здраво! Ја сам Ц++ програмер овде' ;
}
} ;
инт главни ( ) {
ГреетингФунцторЦласс г_фунцтор ;
г_фунцтион ( ) ;
повратак 0 ;
}
Излаз:
Овде можемо приметити да је изјава коју смо додали када смо заменили функцију „оператор()“ у нашем коду приказана овде док зовемо објекат класе као функцију.
Пример 5:
“битс/стдц++.х” је овог пута укључен јер садржи све потребне декларације функција. Затим се овде поставља „стд“ именски простор. Класа коју овде креирамо је класа „инцрементФунцтор“. Затим креирамо „приватни“ конструктор и иницијализујемо променљиву „инт_нум“ са типом података „инт“.
Испод овог, „јавног“ конструктора, постављамо „инцрементФунцтор“ и преносимо „инт н1“ унутар њега. Затим откуцавамо „инт_нум(н1)“ након постављања „:“. Затим замењујемо функцију која је функција „оператор()“ типа података „инт“ и овде декларишемо „инт аррОфНум“. Затим користимо „ретурн“ и убацујемо „инт_нум + аррОфНум“. Сада, ово повећава вредности „аррОфНум“, додаје им вредност „инт_нум“ и враћа их овде.
Након што позовемо „маин()“, ми иницијализујемо „аррОфНум“ и овде додељујемо различите целобројне вредности. Затим се променљива „н1“ иницијализује где додајемо функцију „сизеоф“ као што је „сизеоф(аррОфНум)/сизеоф(аррОфНум[0])“. Након овога, „АддитионНумбер“ се затим иницијализује са „3“. Сада користимо функцију „трансформ()“. Овај „трансформ()“ је исти као креирање објекта класе „инцреаментФунцтор“ и затим позивање његовог објекта. После овога, користимо петљу „фор“, а затим „извлачимо“ „аррОфНум[и]“.
Код 5:
#инцлуде <битс/стдц++.х>Користећи именског простора стд ;
класа инцрементФунцтор
{
приватни :
инт инт_нум ;
јавности :
инцрементФунцтор ( инт н1 ) : инт_нум ( н1 ) { }
инт оператер ( ) ( инт аррОфНум ) конст {
повратак инт_нум + аррОфНум ;
}
} ;
инт главни ( )
{
инт аррОфНум [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
инт н1 = величина ( аррОфНум ) / величина ( аррОфНум [ 0 ] ) ;
инт сабирни број = 3 ;
преобразити ( аррОфНум, аррОфНум + н1, аррОфНум, инцрементФунцтор ( сабирни број ) ) ;
за ( инт и = 0 ; и < н1 ; и ++ )
цоут << аррОфНум [ и ] << ' ' ;
}
Излаз:
Овде је приказан исход кода у коме је „инцрементФунцтор“ „Функтор“ који се користи као функција.
Пример 6:
У овом коду користимо унапред дефинисани „већи“ функтор. Овде укључујемо четири различите датотеке заглавља како их захтевамо у нашем коду јер су функције или методе које су нам потребне у нашем коду декларисане у њима. Затим, након што смо додали „стд“ и затим позвали „маин()“, иницијализујемо вектор „миИнтегерВецтор“. У овај вектор убацујемо неке несортиране вредности. Испод овога примењујемо функцију 'сорт' да сортирамо ове векторске вредности.
Када користимо ову функцију, она сортира вредности у растућем редоследу. Али ми овде користимо „веће“, што је унапред дефинисана функција у Ц++-у која даје резултат сортирања на опадајући начин. Након тога, приказујемо сортиране вредности уз помоћ петље „фор“, а затим „цоут“.
Код 6:
#инцлуде <иостреам>#инцлуде <алгоритам>
#инцлуде <вектор>
#инцлуде <функционално>
Користећи именског простора стд ;
инт главни ( ) {
вектор < инт > миИнтегерВецтор = { 13 , двадесет један , 19 , 44 , 32 , 42 , 9 , 6 } ;
врста ( миИнтегерВецтор. започети ( ) , миИнтегерВецтор. крај ( ) , већи < инт > ( ) ) ;
за ( инт вец_нум : миИнтегерВецтор ) {
цоут << вец_нум << '' ;
}
повратак 0 ;
}
Излаз:
Све вредности вектора се сортирају опадајуће уз помоћ унапред дефинисаног функтора у Ц++ који је „већи“ функтор, а његова дефиниција је доступна у „функционалном“ заглављу.
Закључак
Концепт „функтора Ц++“ је дубоко истражен у овом чланку. Проучили смо да се објекат може позвати као функција за преоптерећење функције која се зове „оператор()“. Ово је познато као функтор. Јавни приступ мора бити обезбеђен да би се преоптерећење „оператора()“ користило како је предвиђено. Илустровали смо различите примере у којима смо користили „функторе“ и унапред дефинисане „функторе“ у нашем коду.