Functie C++ Voorbeelden

Functie C Voorbeelden



Een C++-klasse die als een functie werkt, wordt een functor genoemd. De identieke oude syntaxis van de functieaanroep wordt gebruikt om de functors aan te roepen. We maken een object dat de “operator()” overbelast om een ​​functor te genereren. We kunnen ook zeggen dat de objecten die kunnen worden geïnterpreteerd als een functie of een functieaanwijzer, functoren worden genoemd. Bij het modelleren van de functionele effecten met behulp van de waarden van parametrische gegevenstypen zijn ‘functors’ uiterst handig. In dit artikel wordt het functorconcept in detail bestudeerd, samen met C++-codes.

Voorbeeld 1:

De “iostream” is het headerbestand dat we hier opnemen omdat we de functies moeten gebruiken die in dit headerbestand zijn gedeclareerd. Het headerbestand “iostream” bevat een functiedeclaratie. De naamruimte “std” wordt hier ook toegevoegd. Vervolgens genereren we een klasse met de naam 'FunctorClass'. Hieronder typen we “public”, wat hier de publieke constructor is, en plaatsen we de functie “operator()”. Vervolgens plaatsen we een zin die we willen weergeven op het scherm in de ‘cout’-verklaring.

Hierna roepen we de functie “main()” aan en maken vervolgens het object van de “FunctorClass” met de naam “my_functor”. Hier roepen we de functie “my_functor()” aan, zodat deze de instructie weergeeft die we onder de functie “operator()” hebben toegevoegd.







Code1:



#include
gebruik makend van naamruimte soa ;
klas FunctieKlasse {
openbaar :
leegte exploitant ( ) ( ) {
uit << 'De operatie wordt hier genoemd' ;
}
} ;
int voornaamst ( ) {
FunctorKlasse mijn_functor ;
mijn_functor ( ) ;

opbrengst 0 ;
}

Uitgang:



De regel die we hebben toegevoegd in de functie “operator()” van de “FunctorClass” wordt hier weergegeven door gebruik te maken van het functorobject “my_functor”.





Voorbeeld 2:

We nemen hier het 'iostream'-headerbestand op omdat een bepaalde functiedeclaratie in het 'iostream'-headerbestand is opgenomen. De naamruimte “std” wordt ook ingevoegd. Vervolgens maken we een klasse met de naam 'SquareClass'.



Daaronder typen we ‘public’, wat de openbare constructor is, en plaatsen we de functie ‘operator()’ van het gegevenstype ‘int’ eronder. We geven de variabele “val” van het gegevenstype “int” door aan deze functie “operator()”. Deze functie retourneert het resultaat van de vermenigvuldiging zoals we “val * val” hebben ingevoegd in de functie “return()” onder de functie “operator()”.

Nu wordt hier de functie “main()” aangeroepen. Vervolgens wordt hier het object gemaakt met de naam “s_functor” van de klasse “SquareFunctor”. Vervolgens gebruiken we de “cout” die helpt bij het weergeven van de informatie. Hierna noemen we het object “my_functor()” hier als een functie en het retourneert het vermenigvuldigingsresultaat van “5 * 5” terwijl we “5” als parameter hebben toegevoegd tijdens het aanroepen ervan.

Code2:

#include
gebruik makend van naamruimte soa ;
klas VierkanteKlasse {
openbaar :
int exploitant ( ) ( int val ) {
opbrengst ( val * val ) ;
}
} ;
int voornaamst ( ) {
SquareClass s_functor ;
uit << 'Het kwadraat van de gegeven waarde is ' << eindl ;
uit << s_functie ( 5 ) ;

opbrengst 0 ;
}

Uitgang:

We krijgen de uitvoer nadat we het object “my_functor” van de klasse “SqaureClass” hebben aangeroepen, zoals de functie “my_functor()” en vervolgens “5” hebben doorgegeven. We krijgen “25” als het kwadraat van het getal “5”.

Voorbeeld 3:

Het headerbestand “iostream” is hier opgenomen omdat het een functiedeclaratie bevat, en de naamruimte “std” wordt daarna geïntroduceerd. Vervolgens wordt de klasse “ProductFunctor” gemaakt. De publieke constructor, “public”, wordt eronder getypt en de functie “operator()” van het gegevenstype “int” wordt eronder geplaatst. We overschrijven deze functie hier en geven er twee parameters aan door: “int var1” en “int var2”.

Vervolgens gebruiken we de “return” daaronder en vermenigvuldigen we beide variabelen, wat het vermenigvuldigingsresultaat van beide getallen “var1 * var2” oplevert. Vervolgens wordt hier de functie “main()” aangeroepen en genereren we het klasseobject met de naam “P_functor” van de klasse “ProductFunctor”. Vervolgens initialiseren we een nieuwe variabele met de naam “pro_result” en wijzen we het object “P_functor” toe als de functie “P_functor()” nadat we het hebben aangeroepen.

We geven “28” en “63” door als parameter. Dit zal beide waarden vermenigvuldigen en het resultaat opslaan in de “pro_result” variabele die we hieronder afdrukken met behulp van de “cout” en daarin “pro_result” doorgeven.

Code 3:

#include
gebruik makend van naamruimte soa ;
klas ProductFunctor {
openbaar :
int exploitant ( ) ( int var1, int var2 ) {
opbrengst var1 * var2 ;
}
} ;
int voornaamst ( ) {
ProductFunctor P_functor ;
int product_resultaat = P_functie ( 28 , 63 ) ;
uit << 'Het product is:' << product_resultaat << eindl ;
opbrengst 0 ;
}

Uitgang:

We krijgen het product nadat we het object “P_functor” hebben aangeroepen als de functie “P_functor()” en de waarden eraan hebben doorgegeven. Het product van deze waarden is “1764”.

Voorbeeld 4:

In dit geval wordt de 'GreetingFunctorClass' gegenereerd. Vervolgens voegen we de ‘public’-constructor in en overschrijven we de functie ‘operator()’ in deze ‘public’-constructor. Wij typen “Hallo! Ik ben hier een C++-programmeur” nadat ik de “cout” onder de functie “operator()” heb geplaatst.

Nu noemen we de “main()”. We maken hier de “g_functor” als het object van de “GreetingFunctorClass” en noemen dit object “g_functor” vervolgens de functie “g_functor()”. Dit geeft de uitkomst die we hebben toegevoegd in de functie “operator()” terwijl we deze overschreven.

Code 4:

#include
gebruik makend van naamruimte soa ;
gebruik makend van naamruimte soa ;
klas GroetFunctorClass {
openbaar :
leegte exploitant ( ) ( ) {
uit << 'Hallo! Ik ben hier een C++-programmeur' ;
}
} ;
int voornaamst ( ) {
GreetingFunctorClass g_functor ;
g_functie ( ) ;
opbrengst 0 ;
}

Uitgang:

Hier merken we misschien dat de instructie die we hebben toegevoegd toen we de functie “operator()” in onze code overschreven, hier wordt weergegeven terwijl we het klasseobject als een functie aanroepen.

Voorbeeld 5:

De “bits/stdc++.h” is deze keer opgenomen omdat deze alle noodzakelijke functiedeclaraties bevat. Vervolgens wordt hier de naamruimte 'std' geplaatst. De klasse die we hier maken is de klasse “incrementFunctor”. Vervolgens maken we een ‘privé’-constructor en initialiseren we de variabele ‘int_num’ met het gegevenstype ‘int’.

Daaronder, de “public” constructor, plaatsen we de “incrementFunctor” en geven we “int n1” daarin door. Vervolgens typen we “int_num(n1)” na het plaatsen van de “:”. Vervolgens overschrijven we de functie die de functie “operator()” is van het gegevenstype “int” en declareren we hier “int arrOfNum”. We gebruiken dan de “return” en voegen “int_num + arrOfNum” in. Dit verhoogt nu de waarden van 'arrOfNum', voegt de waarde 'int_num' eraan toe en retourneert ze hier.

Nadat we de “main()” hebben aangeroepen, initialiseren we de “arrOfNum” en wijzen hier verschillende gehele waarden toe. Vervolgens wordt de variabele “n1” geïnitialiseerd waar we de functie “sizeof” toevoegen, zoals “sizeof(arrOfNum)/sizeof(arrOfNum[0])”. Hierna wordt het “additionNumber” geïnitialiseerd met “3”. Nu gebruiken we de functie 'transform()'. Deze “transform()” is hetzelfde als het maken van het object van de klasse “increamentFunctor” en het vervolgens aanroepen van het object ervan. Hierna gebruiken we de “for” lus en “cout” vervolgens de “arrOfNum[i]”.

Code 5:

#include
gebruik makend van naamruimte soa ;
klas verhogingFunctor
{
privaat :
int int_num ;
openbaar :
verhogingFunctor ( int n1 ) : int_num ( n1 ) { }
int exploitant ( ) ( int arrOfNum ) const {
opbrengst int_num + arrOfNum ;
}
} ;
int voornaamst ( )
{
int arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
int n1 = De grootte van ( arrOfNum ) / De grootte van ( arrOfNum [ 0 ] ) ;
int toevoeging nummer = 3 ;
transformeren ( arrOfNum, arrOfNum + n1, arrOfNum, incrementFunctor ( toevoeging nummer ) ) ;

voor ( int i = 0 ; i < n1 ; i ++ )
uit << arrOfNum [ i ] << ' ' ;
}

Uitgang:

Het resultaat van de code wordt hier weergegeven, waarbij “incrementFunctor” de “Functor” is die als functie wordt gebruikt.

Voorbeeld 6:

In deze code gebruiken we de vooraf gedefinieerde 'grotere' functor. Hier nemen we vier verschillende headerbestanden op, omdat we deze nodig hebben in onze code, omdat de functies of methoden die we nodig hebben in onze code daarin worden gedeclareerd. Vervolgens initialiseren we, na het toevoegen van “std” en het aanroepen van “main()”, de vector “myIntegerVector”. We voegen enkele ongesorteerde waarden in deze vector in. Hieronder passen we de functie 'sorteren' toe om deze vectorwaarden te sorteren.

Wanneer we deze functie gebruiken, worden de waarden in oplopende volgorde gesorteerd. Maar we gebruiken hier de “grotere”, de vooraf gedefinieerde functie in C++, die het resultaat geeft van aflopend sorteren. Hierna geven we de gesorteerde waarden weer met behulp van de “for”-lus en vervolgens “cout”.

Code6:

#include
#include
#include
#include
gebruik makend van naamruimte soa ;

int voornaamst ( ) {
vector < int > mijnIntegerVector = { 13 , eenentwintig , 19 , 44 , 32 , 42 , 9 , 6 } ;
soort ( mijnIntegerVector. beginnen ( ) , mijnIntegerVector. einde ( ) , groter < int > ( ) ) ;
voor ( int vec_num : mijnIntegerVector ) {
uit << vec_num << '' ;
}
opbrengst 0 ;
}

Uitgang:

Alle waarden van de vector worden aflopend gesorteerd met behulp van de vooraf gedefinieerde functor in C++, de “grotere” functor, en de definitie ervan is beschikbaar in het “functionele” headerbestand.

Conclusie

Het concept van de “functor C++” wordt in dit artikel diepgaand onderzocht. We hebben onderzocht dat een object kan worden aangeroepen als een functie om een ​​functie genaamd ‘operator()’ te overbelasten. Dit staat bekend als een functor. Er moet openbare toegang worden geboden om ervoor te zorgen dat de “operator()” overbelast raakt, zodat deze zoals bedoeld kan worden gebruikt. We hebben verschillende voorbeelden geïllustreerd waarin we de ‘functors’ en de vooraf gedefinieerde ‘functor’ in onze code hebben gebruikt.