ఉదాహరణ 1:
“iostream” అనేది మేము ఇక్కడ చేర్చిన హెడర్ ఫైల్, ఎందుకంటే ఈ హెడర్ ఫైల్‌లో ప్రకటించబడిన ఫంక్షన్‌లను మనం ఉపయోగించుకోవాలి. “iostream” హెడర్ ఫైల్ ఫంక్షన్ డిక్లరేషన్‌ను కలిగి ఉంది. ఇక్కడ “std” నేమ్‌స్పేస్ కూడా జోడించబడింది. అప్పుడు, మేము 'FunctorClass' అనే తరగతిని రూపొందిస్తాము. దీని క్రింద, మేము ఇక్కడ పబ్లిక్ కన్స్ట్రక్టర్ అయిన “పబ్లిక్” అని టైప్ చేస్తాము మరియు “ఆపరేటర్()” ఫంక్షన్‌ను ఉంచుతాము. అప్పుడు, మేము స్క్రీన్‌పై రెండర్ చేయాలనుకుంటున్న వాక్యాన్ని “కౌట్” స్టేట్‌మెంట్‌లో ఉంచుతాము.
దీని తర్వాత, మేము “main()” ఫంక్షన్‌ని పిలుస్తాము మరియు “my_functor” పేరుతో “FunctorClass” యొక్క ఆబ్జెక్ట్‌ను సృష్టిస్తాము. ఇక్కడ, మేము “my_functor()” ఫంక్షన్‌ని పిలుస్తాము, కనుక ఇది “ఆపరేటర్()” ఫంక్షన్ క్రింద మేము జోడించిన ప్రకటనను ప్రదర్శిస్తుంది.
కోడ్ 1:
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి ఫంక్షన్ క్లాస్ {
ప్రజా :
శూన్యం ఆపరేటర్ ( ) ( ) {
కోట్ << 'ఆపరేషన్ ఇక్కడ ఉంది' ;
}
} ;
int ప్రధాన ( ) {
FunctorClass my_functor ;
నా_ఫంక్టర్ ( ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
“FunctorClass” యొక్క “ఆపరేటర్()” ఫంక్షన్‌లో మేము జోడించిన లైన్ ఇక్కడ “my_functor” ఫంక్టర్ ఆబ్జెక్ట్‌ని ఉపయోగించడం ద్వారా ప్రదర్శించబడుతుంది.
ఉదాహరణ 2:
'iostream' హెడర్ ఫైల్‌లో కొంత ఫంక్షన్ డిక్లరేషన్ ఉన్నందున మేము ఇక్కడ 'iostream' హెడర్ ఫైల్‌ని చేర్చాము. “std” నేమ్‌స్పేస్ కూడా చొప్పించబడింది. తరువాత, మేము 'SquareClass' అనే తరగతిని సృష్టిస్తాము.
దాని క్రింద, మేము పబ్లిక్ కన్స్ట్రక్టర్ అయిన “పబ్లిక్” అని టైప్ చేస్తాము మరియు దాని క్రింద “int” డేటా రకం యొక్క “ఆపరేటర్()” ఫంక్షన్‌ను ఉంచుతాము. మేము ఈ “ఆపరేటర్()” ఫంక్షన్‌కి “int” డేటా రకం యొక్క “val” వేరియబుల్‌ని పాస్ చేస్తాము. “ఆపరేటర్()” ఫంక్షన్ క్రింద “రిటర్న్()” ఫంక్షన్‌లో మనం “val * val”ని చొప్పించినందున ఈ ఫంక్షన్ గుణకార ఫలితాన్ని అందిస్తుంది.
ఇప్పుడు, 'ప్రధాన ()' ఫంక్షన్ ఇక్కడ పిలువబడుతుంది. అప్పుడు, ఆబ్జెక్ట్ ఇక్కడ 'స్క్వేర్ఫంక్టర్' క్లాస్ యొక్క 's_functor' పేరుతో సృష్టించబడుతుంది. అప్పుడు, మేము సమాచారాన్ని అందించడంలో సహాయపడే 'కౌట్'ని ఉపయోగిస్తాము. దీని తర్వాత, మేము ఇక్కడ “my_functor()”ఆబ్జెక్ట్‌ని ఫంక్షన్ లాగా పిలుస్తాము మరియు కాల్ చేస్తున్నప్పుడు మేము “5”ని పారామీటర్‌గా జోడించినప్పుడు అది “5 * 5” యొక్క గుణకార ఫలితాన్ని అందిస్తుంది.
కోడ్ 2:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి స్క్వేర్‌క్లాస్ {
ప్రజా :
int ఆపరేటర్ ( ) ( int విలువ ) {
తిరిగి ( విలువ * విలువ ) ;
}
} ;
int ప్రధాన ( ) {
స్క్వేర్‌క్లాస్ s_ఫంక్టర్ ;
కోట్ << 'ఇచ్చిన విలువ యొక్క వర్గము' << endl ;
కోట్ << s_ఫంక్షన్ ( 5 ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
'my_functor()' ఫంక్షన్ వంటి 'SqaureClass' క్లాస్ యొక్క 'my_functor' ఆబ్జెక్ట్‌ని కాల్ చేసి, ఆపై '5'ని పాస్ చేసిన తర్వాత మనకు అవుట్‌పుట్ వస్తుంది. మనకు '5' సంఖ్య యొక్క వర్గంగా '25' వస్తుంది.
ఉదాహరణ 3:
“iostream” హెడర్ ఫైల్ ఇక్కడ చేర్చబడింది ఎందుకంటే ఇది ఫంక్షన్ డిక్లరేషన్‌ను కలిగి ఉంది మరియు “std” నేమ్‌స్పేస్ తర్వాత పరిచయం చేయబడింది. 'ProductFunctor' తరగతి అప్పుడు తయారు చేయబడింది. పబ్లిక్ కన్స్ట్రక్టర్, “పబ్లిక్”, దాని క్రింద టైప్ చేయబడింది మరియు “int” డేటా రకం యొక్క “ఆపరేటర్()” ఫంక్షన్ దాని క్రింద ఉంచబడుతుంది. మేము ఇక్కడ ఈ ఫంక్షన్‌ను భర్తీ చేస్తాము మరియు దానిలో రెండు పారామితులను పాస్ చేస్తాము: “int var1” మరియు “int var2”.
అప్పుడు, మేము దీని క్రింద ఉన్న “రిటర్న్”ని ఉపయోగిస్తాము మరియు “var1 * var2” రెండు సంఖ్యల గుణకార ఫలితాన్ని అందించే రెండు వేరియబుల్‌లను గుణిస్తాము. 'ప్రధాన()' ఫంక్షన్ అప్పుడు ఇక్కడ పిలువబడుతుంది మరియు మేము 'ProductFunctor' క్లాస్ యొక్క 'P_functor' పేరుతో తరగతి వస్తువును రూపొందిస్తాము. అప్పుడు, మేము 'pro_result' పేరుతో కొత్త వేరియబుల్‌ని ప్రారంభిస్తాము మరియు కాల్ చేసిన తర్వాత 'P_functor' ఆబ్జెక్ట్‌ని 'P_functor()' ఫంక్షన్‌గా కేటాయిస్తాము.
మేము '28' మరియు '63' ను పరామితిగా పాస్ చేస్తాము. ఇది రెండు విలువలను గుణించి, ఫలితాన్ని 'pro_result' వేరియబుల్‌లో సేవ్ చేస్తుంది, మేము దీని క్రింద 'cout'ని ఉపయోగించి ప్రింట్ చేసి అందులో 'pro_result'ని పాస్ చేస్తాము.
కోడ్ 3:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి ఉత్పత్తి ఫంక్టర్ {
ప్రజా :
int ఆపరేటర్ ( ) ( int var1, int var2 ) {
తిరిగి var1 * var2 ;
}
} ;
int ప్రధాన ( ) {
ఉత్పత్తి ఫంక్టర్ P_functor ;
int ఉత్పత్తి_ఫలితం = P_ఫంక్షన్ ( 28 , 63 ) ;
కోట్ << 'ఉత్పత్తి:' << ఉత్పత్తి_ఫలితం << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
“P_functor” ఆబ్జెక్ట్‌ని “P_functor()” ఫంక్షన్‌గా పిలిచి, దానికి విలువలను పంపిన తర్వాత మేము ఉత్పత్తిని పొందుతాము. ఆ విలువల ఉత్పత్తి “1764”.
ఉదాహరణ 4:
ఈ సందర్భంలో 'GreetingFunctorClass' రూపొందించబడింది. అప్పుడు, మేము “పబ్లిక్” కన్స్ట్రక్టర్ని ఇన్సర్ట్ చేస్తాము మరియు ఈ “పబ్లిక్” కన్‌స్ట్రక్టర్‌లో “ఆపరేటర్()” ఫంక్షన్‌ని ఓవర్‌రైడ్ చేస్తాము. మేము 'హలో! 'ఆపరేటర్()' ఫంక్షన్ కింద 'కౌట్'ని ఉంచిన తర్వాత నేను ఇక్కడ C++ ప్రోగ్రామర్‌ని.
ఇప్పుడు మనం 'ప్రధాన ()' అని పిలుస్తాము. మేము ఇక్కడ “G_functor”ని “GreetingFunctorClass” యొక్క ఆబ్జెక్ట్‌గా సృష్టించి, ఆపై ఈ “g_functor” ఆబ్జెక్ట్‌ని “g_functor()” ఫంక్షన్‌గా పిలుస్తాము. ఇది ఓవర్‌రైడ్ చేస్తున్నప్పుడు “ఆపరేటర్()” ఫంక్షన్‌లో మనం జోడించిన ఫలితాన్ని ఇస్తుంది.
కోడ్ 4:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి గ్రీటింగ్ ఫంక్టర్ క్లాస్ {
ప్రజా :
శూన్యం ఆపరేటర్ ( ) ( ) {
కోట్ << 'హలో! నేను ఇక్కడ C++ ప్రోగ్రామర్‌ని' ;
}
} ;
int ప్రధాన ( ) {
గ్రీటింగ్ఫంక్టర్ క్లాస్ g_functor ;
g_ఫంక్షన్ ( ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, మేము మా కోడ్‌లోని “ఆపరేటర్()” ఫంక్షన్‌ను ఓవర్‌రోడ్ చేసినప్పుడు జోడించిన స్టేట్‌మెంట్ ఇక్కడ ప్రదర్శించబడుతుందని మేము గమనించవచ్చు, ఎందుకంటే మేము క్లాస్ ఆబ్జెక్ట్‌ని ఫంక్షన్ లాగా పిలుస్తాము.
ఉదాహరణ 5:
అవసరమైన అన్ని ఫంక్షన్ డిక్లరేషన్‌లను కలిగి ఉన్నందున ఈసారి “bits/stdc++.h” చేర్చబడింది. అప్పుడు, “std” నేమ్‌స్పేస్ ఇక్కడ ఉంచబడుతుంది. మేము ఇక్కడ సృష్టించే తరగతి 'incrementFunctor' తరగతి. అప్పుడు, మేము 'ప్రైవేట్' కన్స్ట్రక్టర్ని సృష్టిస్తాము మరియు 'int' డేటా రకంతో 'int_num' వేరియబుల్‌ని ప్రారంభిస్తాము.
దీని కింద, “పబ్లిక్” కన్స్ట్రక్టర్, మేము “incrementFunctor”ని ఉంచాము మరియు దాని లోపల “int n1”ని పాస్ చేస్తాము. అప్పుడు, ':'ని ఉంచిన తర్వాత మనం 'int_num(n1)' అని టైప్ చేస్తాము. అప్పుడు, మేము “int” డేటా రకం యొక్క “ఆపరేటర్()” ఫంక్షన్‌ని భర్తీ చేస్తాము మరియు ఇక్కడ “int arrOfNum”ని ప్రకటిస్తాము. మేము 'రిటర్న్' ను ఉపయోగిస్తాము మరియు 'int_num + arrOfNum'ని ఇన్సర్ట్ చేస్తాము. ఇప్పుడు, ఇది “arrOfNum” విలువలను పెంచుతుంది, వాటిలో “int_num” విలువను జోడిస్తుంది మరియు వాటిని ఇక్కడకు అందిస్తుంది.
“main()”ని ప్రారంభించిన తర్వాత, మేము “arrOfNum”ని ప్రారంభిస్తాము మరియు ఇక్కడ విభిన్న పూర్ణాంక విలువలను కేటాయిస్తాము. అప్పుడు, “sizeof(arrOfNum)/sizeof(arrOfNum[0])” వంటి “sizeof” ఫంక్షన్‌ని జోడించే చోట “n1” వేరియబుల్ ప్రారంభించబడుతుంది. దీని తరువాత, 'additionNumber' తర్వాత '3'తో ప్రారంభించబడుతుంది. ఇప్పుడు, మేము 'ట్రాన్స్ఫార్మ్()' ఫంక్షన్‌ని ఉపయోగిస్తాము. ఈ “ట్రాన్స్ఫార్మ్()” అనేది “increammentFunctor” క్లాస్ యొక్క ఆబ్జెక్ట్‌ని సృష్టించి, ఆపై దాని ఆబ్జెక్ట్‌ని పిలుస్తుంది. దీని తర్వాత, మేము 'ఫర్' లూప్‌ని ఉపయోగిస్తాము మరియు 'arrOfNum[i]'ని 'కౌట్' చేస్తాము.
కోడ్ 5:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
తరగతి ఇంక్రిమెంట్ఫంక్టర్
{
ప్రైవేట్ :
int int_num ;
ప్రజా :
ఇంక్రిమెంట్ఫంక్టర్ ( int n1 ) : int_num ( n1 ) { }
int ఆపరేటర్ ( ) ( int arrOfNum ) స్థిరంగా {
తిరిగి int_num + arrOfNum ;
}
} ;
int ప్రధాన ( )
{
int arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
int n1 = పరిమాణం ( arrOfNum ) / పరిమాణం ( arrOfNum [ 0 ] ) ;
int అదనపు సంఖ్య = 3 ;
రూపాంతరము ( arrOfNum, arrOfNum + n1, arrOfNum, ఇంక్రిమెంట్ ఫంక్టర్ ( అదనపు సంఖ్య ) ) ;
కోసం ( int i = 0 ; i < n1 ; i ++ )
కోట్ << arrOfNum [ i ] << '' ;
}
అవుట్‌పుట్:
కోడ్ యొక్క ఫలితం ఇక్కడ చూపబడింది, దీనిలో 'ఇంక్రిమెంట్ ఫంక్టర్' అనేది 'ఫంక్టర్', అది ఫంక్షన్‌గా ఉపయోగించబడుతుంది.
ఉదాహరణ 6:
ఈ కోడ్‌లో, మేము ముందే నిర్వచించబడిన “గ్రేటర్” ఫంక్టర్‌ని ఉపయోగిస్తాము. ఇక్కడ, మేము మా కోడ్‌లో నాలుగు వేర్వేరు హెడర్ ఫైల్‌లను చేర్చాము, ఎందుకంటే మా కోడ్‌లో మనకు అవసరమైన ఫంక్షన్‌లు లేదా పద్ధతులు వాటిలో ప్రకటించబడతాయి. ఆపై, “std”ని జోడించి, ఆపై “main()”కి కాల్ చేసిన తర్వాత, మేము “myIntegerVector” వెక్టర్‌ని ప్రారంభిస్తాము. మేము ఈ వెక్టర్‌లో కొన్ని క్రమబద్ధీకరించని విలువలను చొప్పించాము. దీని క్రింద, మేము ఈ వెక్టర్ విలువలను క్రమబద్ధీకరించడానికి “క్రమబద్ధీకరించు” ఫంక్షన్‌ను వర్తింపజేస్తాము.
మేము ఈ ఫంక్షన్‌ను ఉపయోగించినప్పుడు, ఇది విలువలను ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది. కానీ మేము ఇక్కడ 'గ్రేటర్'ని ఉపయోగించుకుంటాము, ఇది C++లో ముందే నిర్వచించబడిన ఫంక్షన్, ఇది అవరోహణ పద్ధతిలో క్రమబద్ధీకరణ ఫలితాన్ని ఇస్తుంది. దీని తరువాత, మేము 'ఫర్' లూప్ మరియు తరువాత 'కౌట్' సహాయంతో క్రమబద్ధీకరించబడిన విలువలను ప్రదర్శిస్తాము.
కోడ్ 6:
##
#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
వెక్టర్ < int > myIntegerVector = { 13 , ఇరవై ఒకటి , 19 , 44 , 32 , 42 , 9 , 6 } ;
క్రమబద్ధీకరించు ( myIntegerVector. ప్రారంభం ( ) , myIntegerVector. ముగింపు ( ) , ఎక్కువ < int > ( ) ) ;
కోసం ( int vec_num : myIntegerVector ) {
కోట్ << vec_num << '' ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
వెక్టర్ యొక్క అన్ని విలువలు 'గ్రేటర్' ఫంక్టర్ అయిన C++లో ముందే నిర్వచించిన ఫంక్టర్ సహాయంతో అవరోహణ పద్ధతిలో క్రమబద్ధీకరించబడతాయి మరియు దాని నిర్వచనం 'ఫంక్షనల్' హెడర్ ఫైల్‌లో అందుబాటులో ఉంటుంది.
ముగింపు
'ఫంక్టర్ C++' భావన ఈ వ్యాసంలో లోతుగా అన్వేషించబడింది. “ఆపరేటర్()” అనే ఫంక్షన్‌ని ఓవర్‌లోడ్ చేయడానికి ఒక ఆబ్జెక్ట్‌ని ఫంక్షన్‌గా అమలు చేయవచ్చని మేము అధ్యయనం చేసాము. దీనిని ఫంక్టర్ అంటారు. 'ఆపరేటర్()' యొక్క ఓవర్‌లోడింగ్‌ను ఉద్దేశించిన విధంగా వినియోగించుకోవడానికి పబ్లిక్ యాక్సెస్ తప్పనిసరిగా అందించబడాలి. మేము మా కోడ్‌లోని “ఫంక్టర్‌లు” మరియు ముందే నిర్వచించిన “ఫంక్టర్”ని ఉపయోగించిన విభిన్న ఉదాహరణలను వివరించాము.