דוגמה 1:
ה-'iostream' הוא קובץ הכותרת שאנו כוללים כאן מכיוון שעלינו להשתמש בפונקציות המוצהרות בקובץ הכותרת הזה. קובץ הכותרת 'iostream' מכיל הצהרת פונקציה. גם מרחב השמות 'std' נוסף כאן. לאחר מכן, אנו יוצרים מחלקה בשם 'FunctorClass'. מתחת לזה, אנו מקלידים כאן 'public' שהוא הבנאי הציבורי וממקמים את הפונקציה 'operator()'. לאחר מכן, אנו מניחים משפט שאנו רוצים להציג על המסך בהצהרת 'cout'.
לאחר מכן, אנו קוראים לפונקציה 'main()' ואז יוצרים את האובייקט של 'FunctorClass' עם השם, 'my_functor'. כאן, אנו קוראים לפונקציה 'my_functor()' כך שהיא מציגה את ההצהרה שהוספנו מתחת לפונקציה 'operator()'.
קוד 1:
#include
באמצעות מרחב שמות סטד ;
מעמד FunctorClass {
פּוּמְבֵּי :
בָּטֵל מַפעִיל ( ) ( ) {
cout << 'המבצע נקרא כאן' ;
}
} ;
int רָאשִׁי ( ) {
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באמצעות מרחב שמות סטד ;
מעמד SquareClass {
פּוּמְבֵּי :
int מַפעִיל ( ) ( int val ) {
לַחֲזוֹר ( val * val ) ;
}
} ;
int רָאשִׁי ( ) {
SquareClass s_functor ;
cout << 'ריבוע הערך הנתון הוא' << endl ;
cout << s_function ( 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באמצעות מרחב שמות סטד ;
מעמד ProductFunctor {
פּוּמְבֵּי :
int מַפעִיל ( ) ( int var1, int גרסה 2 ) {
לַחֲזוֹר var1 * גרסה 2 ;
}
} ;
int רָאשִׁי ( ) {
ProductFunctor P_functor ;
int prod_result = P_function ( 28 , 63 ) ;
cout << 'המוצר הוא:' << prod_result << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
אנו מקבלים את המוצר לאחר קריאה לאובייקט 'P_functor' כפונקציה 'P_functor()' ומעבירים אליו את הערכים. המכפלה של ערכים אלה היא '1764'.
דוגמה 4:
ה-'GreetingFunctorClass' נוצר במקרה זה. לאחר מכן, אנו מכניסים את הבנאי 'ציבורי' ומעקפים את פונקציית 'המפעיל()' בבנאי ה'ציבורי' הזה. אנו מקלידים 'שלום! אני מתכנת C++ כאן' לאחר שהצבתי את ה-'cout' מתחת לפונקציה 'operator()'.
כעת ואילך, אנו קוראים ל-'main()'. אנו יוצרים את 'g_functor' כאן כאובייקט של 'GreetingFunctorClass' ולאחר מכן קוראים לאובייקט 'g_functor' זה כפונקציה 'g_functor()'. זה נותן את התוצאה שהוספנו בפונקציה 'operator()' תוך כדי עקיפה.
קוד 4:
#includeבאמצעות מרחב שמות סטד ;
באמצעות מרחב שמות סטד ;
מעמד GreetingFunctorClass {
פּוּמְבֵּי :
בָּטֵל מַפעִיל ( ) ( ) {
cout << 'שלום! אני מתכנת C++ כאן' ;
}
} ;
int רָאשִׁי ( ) {
GreetingFunctorClass g_functor ;
g_function ( ) ;
לַחֲזוֹר 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' ולאחר מכן 'מוציאים' את ה-'arrOfNum[i]'.
קוד 5:
#includeבאמצעות מרחב שמות סטד ;
מעמד incrementFunctor
{
פְּרָטִי :
int int_num ;
פּוּמְבֵּי :
incrementFunctor ( int n1 ) : int_num ( n1 ) { }
int מַפעִיל ( ) ( int arrOfNum ) const {
לַחֲזוֹר int_num + arrOfNum ;
}
} ;
int רָאשִׁי ( )
{
int arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
int n1 = מידה של ( arrOfNum ) / מידה של ( arrOfNum [ 0 ] ) ;
int מספר תוספת = 3 ;
שינוי צורה ( arrOfNum, arrOfNum + n1, arrOfNum, incrementFunctor ( מספר תוספת ) ) ;
ל ( int אני = 0 ; אני < n1 ; אני ++ )
cout << arrOfNum [ אני ] << '' ;
}
תְפוּקָה:
תוצאת הקוד מוצגת כאן שבה 'incrementFunctor' הוא ה'Functor' המשמש כפונקציה.
דוגמה 6:
בקוד זה, אנו משתמשים בפונקטור 'גדול' המוגדר מראש. כאן, אנו כוללים ארבעה קובצי כותרות שונים כפי שאנו דורשים אותם בקוד שלנו מכיוון שהפונקציות או השיטות שאנו צריכים בקוד שלנו מוצהרות בהן. לאחר מכן, לאחר הוספת 'std' ולאחר מכן קריאה ל-'main()', אנו מאתחלים את הווקטור 'myIntegerVector'. אנו מכניסים כמה ערכים לא ממוינים בווקטור זה. מתחת לזה, אנו מיישמים את הפונקציה 'מיין' כדי למיין את ערכי הווקטור הללו.
כאשר אנו משתמשים בפונקציה זו, היא ממיין את הערכים בסדר עולה. אבל אנחנו מנצלים את ה'גדול' כאן שהיא הפונקציה המוגדרת מראש ב-C++ שנותנת את התוצאה של מיון בצורה יורדת. לאחר מכן, אנו מציגים את הערכים הממוינים בעזרת לולאה 'for' ולאחר מכן 'cout'.
קוד 6:
#include#include <אלגוריתם>
#include
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
וֶקטוֹר < int > myIntegerVector = { 13 , עשרים ואחת , 19 , 44 , 32 , 42 , 9 , 6 } ;
סוג ( myIntegerVector. התחל ( ) , myIntegerVector. סוֹף ( ) , גדול יותר < int > ( ) ) ;
ל ( int vec_num : myIntegerVector ) {
cout << vec_num << '' ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כל ערכי הווקטור ממוינים בצורה יורדת בעזרת הפונקטור המוגדר מראש ב-C++ שהוא הפונקטור 'הגדול יותר', והגדרתו זמינה בקובץ הכותרת ה'פונקציונלי'.
סיכום
הרעיון של 'פונקטור C++' נחקר לעומק במאמר זה. למדנו שניתן להפעיל אובייקט כפונקציה להעמיס על פונקציה שנקראת 'operator()'. זה ידוע בתור פונקטור. יש לספק גישה לציבור כדי שהעומס יתר של 'המפעיל()' ינוצל כמתוכנן. הדגמנו דוגמאות שונות שבהן השתמשנו ב'פונקטורים' וב'מפונקטור' המוגדרים מראש בקוד שלנו.