Funkcja C++ Przykłady

Funkcja C Przyklady



Klasę C++, która działa jak funkcja, nazywa się funktorem. Do wywoływania funktorów używana jest ta sama stara składnia wywołań funkcji. Tworzymy obiekt, który przeciąża „operator()” w celu wygenerowania funktora. Można również powiedzieć, że obiekty, które można interpretować jako funkcję lub wskaźnik funkcji, nazywane są funktorami. Przy modelowaniu efektów funkcjonalnych z wykorzystaniem wartości parametrycznych typów danych niezwykle wygodne są „funktory”. W tym artykule szczegółowo omówiona zostanie koncepcja funktora wraz z kodami C++.

Przykład 1:

„iostream” to plik nagłówkowy, który tutaj zamieszczamy, ponieważ musimy wykorzystać funkcje zadeklarowane w tym pliku nagłówkowym. Plik nagłówkowy „iostream” zawiera deklarację funkcji. Dodano tutaj także przestrzeń nazw „std”. Następnie generujemy klasę o nazwie „FunctorClass”. Poniżej wpisujemy „public”, który jest tutaj konstruktorem publicznym i umieszczamy funkcję „operator()”. Następnie w instrukcji „cout” umieszczamy zdanie, które chcemy wyświetlić na ekranie.

Następnie wywołujemy funkcję „main()”, a następnie tworzymy obiekt „FunctorClass” o nazwie „my_functor”. Tutaj wywołujemy funkcję „my_functor()”, aby wyświetlić instrukcję dodaną poniżej funkcji „operator()”.







Kod 1:



#include
za pomocą przestrzeń nazw st ;
klasa Klasa Funktora {
publiczny :
próżnia operator ( ) ( ) {
cout << „Operacja nazywa się tutaj” ;
}
} ;
wew główny ( ) {
FunctorClass my_functor ;
mój_funktor ( ) ;

powrót 0 ;
}

Wyjście:



Linia, którą dodaliśmy w funkcji „operator()” klasy „FunctorClass” jest tutaj wyświetlana przy użyciu obiektu funkcyjnego „my_functor”.





Przykład 2:

Zamieszczamy tutaj plik nagłówkowy „iostream”, ponieważ w pliku nagłówkowym „iostream” znajdują się pewne deklaracje funkcji. Wstawiona jest także przestrzeń nazw „std”. Następnie tworzymy klasę o nazwie „SquareClass”.



Poniżej wpisujemy „public”, który jest konstruktorem publicznym i umieszczamy pod nim funkcję „operator()” typu danych „int”. Do tej funkcji „operator()” przekazujemy zmienną „val” typu danych „int”. Ta funkcja zwraca wynik mnożenia po wstawieniu „val * val” w funkcji „return()” poniżej funkcji „operator()”.

Teraz wywoływana jest tutaj funkcja „main()”. Następnie tworzony jest tu obiekt o nazwie „s_functor” klasy „SquareFunctor”. Następnie używamy „cout”, który pomaga w renderowaniu informacji. Następnie wywołujemy tutaj obiekt „my_functor()” jak funkcję, który zwraca wynik mnożenia „5 * 5”, ponieważ dodaliśmy „5” jako parametr podczas jego wywoływania.

Kod 2:

#include
za pomocą przestrzeń nazw st ;
klasa Klasa kwadratowa {
publiczny :
wew operator ( ) ( wew wal ) {
powrót ( wal * wal ) ;
}
} ;
wew główny ( ) {
Funktor klasy kwadratowej ;
cout << „Kwadrat podanej wartości to” << koniec ;
cout << s_funkcja ( 5 ) ;

powrót 0 ;
}

Wyjście:

Dane wyjściowe otrzymujemy po wywołaniu obiektu „my_functor” klasy „SqaureClass”, np. funkcji „my_functor()”, a następnie przekazaniu wartości „5”. Otrzymujemy „25” jako kwadrat liczby „5”.

Przykład 3:

Dołączono tutaj plik nagłówkowy „iostream”, ponieważ zawiera on deklarację funkcji, a następnie wprowadzono przestrzeń nazw „std”. Następnie tworzona jest klasa „ProductFunctor”. Pod nim wpisywany jest publiczny konstruktor „public”, a pod nim umieszczana jest funkcja „operator()” typu danych „int”. Nadpisujemy tutaj tę funkcję i przekazujemy do niej dwa parametry: „int var1” i „int var2”.

Następnie wykorzystujemy „zwrot” poniżej i mnożymy obie zmienne, co daje wynik mnożenia obu liczb „zmienna1 * zmienna2”. Następnie wywoływana jest tutaj funkcja „main()” i generujemy obiekt klasy o nazwie „P_functor” klasy „ProductFunctor”. Następnie inicjujemy nową zmienną o nazwie „pro_result” i po jej wywołaniu przypisujemy obiektowi „P_functor” funkcję „P_functor()”.

Jako parametr przekazujemy „28” i „63”. Spowoduje to pomnożenie obu wartości i zapisanie wyniku w zmiennej „pro_result”, którą drukujemy poniżej, używając „cout” i przekazując w niej „pro_result”.

Kod 3:

#include
za pomocą przestrzeń nazw st ;
klasa ProduktFunktor {
publiczny :
wew operator ( ) ( wew zmienna1, wew zmienna2 ) {
powrót zm.1 * zmienna2 ;
}
} ;
wew główny ( ) {
Funkcja produktu P_functor ;
wew prod_result = Funkcja P ( 28 , 63 ) ;
cout << „Produkt to:” << prod_result << koniec ;
powrót 0 ;
}

Wyjście:

Produkt otrzymamy po wywołaniu obiektu „P_functor” jako funkcji „P_functor()” i przekazaniu mu wartości. Iloczynem tych wartości jest „1764”.

Przykład 4:

W tym przypadku generowana jest klasa „GreetingFunctorClass”. Następnie wstawiamy konstruktor „publiczny” i nadpisujemy funkcję „operator()” w tym konstruktorze „publicznym”. Piszemy „Witajcie! Jestem programistą C++” po umieszczeniu „cout” pod funkcją „operator()”.

Teraz wywołujemy funkcję „main()”. Tworzymy tutaj „g_functor” jako obiekt „GreetingFunctorClass”, a następnie wywołujemy ten obiekt „g_functor” jako funkcję „g_functor()”. Daje to wynik, który dodaliśmy w funkcji „operator()” podczas jej zastępowania.

Kod 4:

#include
za pomocą przestrzeń nazw st ;
za pomocą przestrzeń nazw st ;
klasa PowitanieFunctorClass {
publiczny :
próżnia operator ( ) ( ) {
cout << „Witam! Jestem tutaj programistą C++” ;
}
} ;
wew główny ( ) {
PowitanieFunctorKlasa g_functor ;
funkcja_g ( ) ;
powrót 0 ;
}

Wyjście:

Tutaj możemy zauważyć, że instrukcja, którą dodaliśmy, gdy zastąpiliśmy funkcję „operator()” w naszym kodzie, jest tutaj wyświetlana, gdy wywołujemy obiekt klasy jak funkcję.

Przykład 5:

Tym razem dołączono plik „bits/stdc++.h”, który zawiera wszystkie niezbędne deklaracje funkcji. Następnie umieszczana jest tutaj przestrzeń nazw „std”. Klasa, którą tutaj tworzymy, to klasa „inkrementacjaFunctor”. Następnie tworzymy „prywatny” konstruktor i inicjujemy zmienną „int_num” typem danych „int”.

Pod konstruktorem „publicznym” umieszczamy funkcję „inkrementacjęFunctor” i przekazujemy do niej „int n1”. Następnie wpisujemy „int_num(n1)” po umieszczeniu „:”. Następnie nadpisujemy funkcję, która jest funkcją „operator()” typu danych „int” i deklarujemy tutaj „int arrOfNum”. Następnie używamy „return” i wstawiamy „int_num + arrOfNum”. Teraz zwiększa to wartości „arrOfNum”, dodaje do nich wartość „int_num” i zwraca je tutaj.

Po wywołaniu „main()” inicjujemy „arrOfNum” i przypisujemy tutaj różne wartości całkowite. Następnie inicjowana jest zmienna „n1”, do której dodajemy funkcję „sizeof”, taką jak „sizeof(arrOfNum)/sizeof(arrOfNum[0])”. Następnie „additionNumber” jest inicjowany wartością „3”. Teraz używamy funkcji „transform()”. Ta funkcja „transform()” jest równoznaczna z utworzeniem obiektu klasy „increamentFunctor”, a następnie wywołaniem jego obiektu. Następnie używamy pętli „for”, a następnie „cout” z „arrOfNum[i]”.

Kod 5:

#include
za pomocą przestrzeń nazw st ;
klasa funkcja przyrostu
{
prywatny :
wew int_num ;
publiczny :
funkcja przyrostu ( wew n1 ) : int_num ( n1 ) { }
wew operator ( ) ( wew arrOfNum ) konst {
powrót int_num + arrOfNum ;
}
} ;
wew główny ( )
{
wew arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
wew n1 = rozmiar ( arrOfNum ) / rozmiar ( arrOfNum [ 0 ] ) ;
wew numer dodatku = 3 ;
przekształcać ( arrOfNum, arrOfNum + n1, arrOfNum, funkcja przyrostu ( numer dodatku ) ) ;

Do ( wew I = 0 ; I < n1 ; I ++ )
cout << arrOfNum [ I ] << ' ' ;
}

Wyjście:

Tutaj pokazano wynik kodu, w którym „inkrementFunctor” to „Functor” używany jako funkcja.

Przykład 6:

W tym kodzie używamy predefiniowanego funktora „większego”. Tutaj dołączamy cztery różne pliki nagłówkowe, ponieważ są one wymagane w naszym kodzie, ponieważ zadeklarowano w nich funkcje lub metody, których potrzebujemy w naszym kodzie. Następnie po dodaniu „std” i wywołaniu „main()” inicjujemy wektor „myIntegerVector”. Wstawiamy do tego wektora kilka nieposortowanych wartości. Poniżej stosujemy funkcję „sortowania”, aby posortować wartości wektorów.

Kiedy korzystamy z tej funkcji, sortuje ona wartości w kolejności rosnącej. Ale używamy tutaj „większej”, która jest predefiniowaną funkcją w C++, która daje wynik sortowania w sposób malejący. Następnie wyświetlamy posortowane wartości za pomocą pętli „for”, a następnie „cout”.

Kod 6:

#include
#include
#uwzględnij
#include
za pomocą przestrzeń nazw st ;

wew główny ( ) {
wektor < wew > mój wektor całkowity = { 13 , dwadzieścia jeden , 19 , 44 , 32 , 42 , 9 , 6 } ;
sortować ( mój wektor całkowity. zaczynać ( ) , mójWektor całkowity. koniec ( ) , większy < wew > ( ) ) ;
Do ( wew vec_num : mój wektor całkowity ) {
cout << vec_num << „” ;
}
powrót 0 ;
}

Wyjście:

Wszystkie wartości wektora sortowane są malejąco za pomocą predefiniowanego w C++ funktora, który jest funktorem „większym”, a jego definicja dostępna jest w „funkcjonalnym” pliku nagłówkowym.

Wniosek

W tym artykule szczegółowo omówiono koncepcję „funktora C++”. Sprawdziliśmy, że obiekt można wywołać jako funkcję w celu przeciążenia funkcji zwanej „operatorem()”. Nazywa się to funktorem. Aby przeciążenie „operatora()” mogło zostać wykorzystane zgodnie z przeznaczeniem, należy zapewnić dostęp publiczny. Zilustrowaliśmy różne przykłady, w których wykorzystaliśmy „funktory” i predefiniowany „funktor” w naszym kodzie.