דוגמה 1: ניצול הטפולים/זוגות
בואו נעשה הדגמה מעשית להחזרת ערכים מרובים ב-C++. כאן, אנו משתמשים בטכניקות tuples/pairs כדי לעזור להחזיר ערכים מרובים בקוד שלנו. C++ מספק קבצי כותרות שונים שעלינו לכלול בקוד שלנו. אנו כוללים כאן 'bits/stdc++.h' מכיוון שהוא מכיל את כל הספריות של תכנות C++. לאחר מכן, מתווסף כאן מרחב השמות שהוא 'std'. לאחר מכן, אנו משתמשים במילת המפתח 'tuple' שבה אנו ממקמים שלושה סוגי נתונים, שני סוגי נתונים צפים, וסוג הנתונים 'char' הנותר. מתחתיו, אנו משתמשים במילת המפתח 'החזרה' כדי לארוז את הערכים כדי להחזיר tuple.
כעת, אנו משתמשים בשיטת ה'זוג' כדי להחזיר ערכים מרובים. בשיטת 'זוג' זו, שמנו שני סוגי נתונים של משתנים, ושניהם 'צפים' כאן. המשתנים נקראים 'float_1' ו-'float_2'. לאחר מכן, אנו אורזים שני ערכים כדי לחזור ל'זוגות'. לאחר מכן, אנו מפעילים את ה-'main()' כאן ואז מכריזים על שני משתני 'float' עם השם 'f_1, f_2'. המשתנה 'char' מוצהר כאן גם בתור 'myChar'. לאחר מכן, אנו מפרקים את הערכים המוחזרים על ידי הפונקציה 'My_Tuple()'.
מתחת לזה, אנו מאחסנים את הערכים המוחזרים בזוגות. אנו מאחסנים '4.99, 8.98' בפונקציה 'My_Tuple' ו-'6.86, 3.22' בפונקציה 'My_Pair'. לאחר מכן, אנו משתמשים ב-'cout' שמדפיס את כל המידע הכתוב בתוכו.
קוד 1:
#include
באמצעות מרחב שמות סטד ;
tuple < לָצוּף , לָצוּף , לְהַשְׁחִיר > My_Tuple ( לָצוּף f_1, לָצוּף f_2 ) {
לַחֲזוֹר make_tuple ( f_2, f_1, '$' ) ;
}
זוג < לָצוּף , לָצוּף > My_Pair ( לָצוּף f_a, לָצוּף פֶּנסיוֹן מָלֵא ) {
לַחֲזוֹר make_pair ( f_b, f_a ) ;
}
int רָאשִׁי ( ) {
לָצוּף f_1,f_2 ;
לְהַשְׁחִיר myChar ;
עניבה ( f_1, f_2, myChar ) = My_Tuple ( 4.99 , 8.98 ) ;
זוג new_p = My_Pair ( 6.86 , 3.22 ) ;
cout << 'ערכים שאנו מקבלים לפי tuples:' ;
cout << f_1 << '' << f_2 << '' << myChar << endl ;
cout << 'ערכים שאנו מקבלים על ידי זוג:' ;
cout << new_p. ראשון << '' << new_p. שְׁנִיָה ;
לַחֲזוֹר 0 ;
}
תְפוּקָה :
הערכים שאנו מקבלים כאן על ידי שימוש בשיטת ה'טופלים' ושיטת ה'זוג' מוצגים בהמשך. שימו לב שהוא מחזיר כאן מספר ערכים.
דוגמה 2: שימוש במצביעים
אנו מעבירים את הפרמטרים יחד עם הכתובות שלהם בפונקציית 'השוואה' כאן. אנו מוסיפים 'value_1' ו-'value_2' מסוג 'int' ואת ה-'int* g_Address, int* s_Address'. לאחר מכן, אנו משתמשים בתנאי 'אם' שבו נוסיף תנאי שה-'value_1' גדול מ-'value_2'. אם זה מסופק, ההצהרה הבאה מבוצעת. אם לא, הוא מתעלם מהמשפט שמתווסף מתחת לזה ועובר לעבר החלק 'אחר'. כעת, לאחר הפעלת ה-'main()', אנו מכריזים על ארבעה משתנים חדשים עם השמות 'g_value', 's_value', 'newValue1' ו-'newValue2'.
לאחר מכן, אנו מדפיסים הודעה להזנת המספרים ולאחר מכן מניחים 'cin' שמקבל שני ערכים מהמשתמש. הערכים שהמשתמש מזין נשמרים במשתנים 'newValue1' ו-'newValue2', בהתאמה. לאחר מכן, אנו קוראים לפונקציה 'compare()' שיצרנו בעבר ומעבירים לתוכה ארבעה פרמטרים. לאחר מכן, אנו מציגים את התוצאה לאחר ביצוע הפונקציה 'השוואה' והיא מציגה את המספר הגדול והמספר הקטן יותר מאותם מספרים שהמשתמש מזין.
קוד 2:
#includeבאמצעות מרחב שמות סטד ;
בָּטֵל לְהַשְׁווֹת ( int ערך_1, int ערך_2, int * g_כתובת, int * s_כתובת )
{
אם ( value_1 > ערך_2 ) {
* g_כתובת = value_1 ;
* s_כתובת = ערך_2 ;
}
אַחֵר {
* g_כתובת = ערך_2 ;
* s_כתובת = value_1 ;
}
}
int רָאשִׁי ( )
{
int g_value, s_value, newValue_1, newValue_2 ;
cout << 'אנא הזן שני מספרים:' <> newValue_1 >> newValue_2 ;
לְהַשְׁווֹת ( newValue_1, newValue_2, & g_value, & s_value ) ;
cout << ' \n המספר הגדול יותר הוא ' << g_value << 'והמספר הקטן יותר הוא'
<< s_value ;
לַחֲזוֹר 0 ;
}
תְפוּקָה :
המשתמש מזין כאן '86' ו-'23'. לאחר הקשה על 'Enter', הוא מציג את התוצאה. בדרך זו, אנו מקבלים מספר ערכים.
דוגמה 3: שימוש במערך
אנו יוצרים כאן את הפונקציה 'ComputeComparison()' בה נכניס שני משתנים, 'num_1' ו-'num_2', כסוג 'int' וגם מערך בשם 'my_arr[]'. לאחר מכן, יש לנו את התנאי 'אם' שבודק אם 'num_1' גדול מ-'num_2' או לא. אם זה נכון, ה-'num_1' מוקצה ל-'my_arr[0]' ו-'num_2' מוקצה ל-'my_arr[1]'. אבל אם התנאי אינו נכון, ההצהרות שאחרי 'else' מבוצעות בהן אנו מקצים 'num_2' ל-'my_arr[0]' ו-'num_1' ל-'my_arr[1]'.
לאחר מכן, אנו קוראים ל-'main()' כאן ואז מכריזים על שני משתני int נוספים: 'newNum_1' ו-'newNum_2'. לאחר מכן, מוצהר מערך בגודל '2'. לאחר מכן, אנו מקבלים שני מספרים מהמשתמש בעזרת 'cin' ואז קוראים לפונקציה 'ComputeComparison()' ומציגים את התוצאה הבאה. אז זה מחזיר כאן מספר ערכים.
קוד 3:
#includeבאמצעות מרחב שמות סטד ;
בָּטֵל ComputeComparison ( int מספר_1, int מספר_2, int my_arr [ ] )
{
אם ( מספר_1 > מספר_2 ) {
my_arr [ 0 ] = מספר_1 ;
my_arr [ 1 ] = מספר_2 ;
}
אַחֵר {
my_arr [ 0 ] = מספר_2 ;
my_arr [ 1 ] = מספר_1 ;
}
}
int רָאשִׁי ( )
{
int newNum_1, newNum_2 ;
int my_arr [ 2 ] ;
cout << 'אנא הזן שני מספרים להשוואה' <> newNum_1 >> newNum_2 ;
ComputeComparison ( newNum_1, newNum_2, my_arr ) ;
cout << ' \n המספר הגדול יותר הוא ' << my_arr [ 0 ] << ' וה '
'מספר קטן יותר הוא' << my_arr [ 1 ] ;
לַחֲזוֹר 0 ;
}
תְפוּקָה :
אנו מקלידים כאן גם '54' וגם '98' ואז לוחצים על 'Enter' כדי להציג את התוצאה. זה מציג את המספרים הגדולים והקטנים יותר מהמספרים שהזנו.
דוגמה 4: שימוש ב- Tuples
שני קובצי כותרות כלולים כאן: 'tuple' ו-'iostream'. לאחר מכן, מרחב השמות 'std' מושם כאן. לאחר מכן, אנו משתמשים במילת המפתח 'tuple' ומכניסים שני סוגי נתונים שהם 'int'. לאחר מכן, אנו יוצרים פונקציה עם השם 'findingValues()' ומעבירים את 'intValue_1' ו-'intValue2' כפרמטרים שלה.
לאחר מכן, ה-'if' ממוקם במקום בו אנו מקלידים את התנאי 'intValue_1 < intValue_2'. מתחתיה, אנו משתמשים במילת המפתח 'return' וממקמים את הפונקציה 'make_tuple()' שבה שני המשתנים מתווספים כפרמטר 'intValue_1, intValue2_'. לאחר מכן, יש לנו את החלק 'אחר' שבו אנו שמים את 'החזרה' שוב יחד עם הפונקציה 'make_tuple()'. אבל כאן, אנו מניחים תחילה את 'intValue_2' ולאחר מכן את 'intValue1'. כעת, אנו קוראים ל-'main()' ומאתחלים את ה-'new_value1' עם '5' ו-'new_value2' עם '28'.
בהמשך, אנו מכריזים על שני משתנים נוספים מסוג 'int' עם השמות 'גדול' ו'קטן'. לאחר מכן, אנו מניחים את הפונקציה 'tie()' ומעבירים את המשתנים 'קטנים, גדולים יותר' כפרמטר וגם קוראים לפונקציה 'findingValues()' כאן. לאחר מכן, נדפיס את שני הערכים: את המספרים הגדולים והקטנים יותר.
קוד 4:
#include#include
באמצעות מרחב שמות סטד ;
tuple findingValues ( int intValue_1, int intValue_2 )
{
אם ( intValue_1 < intValue_2 ) {
לַחֲזוֹר make_tuple ( intValue_1 , intValue_2 ) ;
}
אַחֵר {
לַחֲזוֹר make_tuple ( intValue_2 , intValue_1 ) ;
}
}
int רָאשִׁי ( )
{
int new_value1 = 5 , new_value2 = 28 ;
int גדול יותר, קטן יותר ;
עניבה ( קטן יותר, גדול יותר ) = למצוא ערכים ( new_value1, new_value2 ) ;
printf ( 'המספר הגדול יותר הוא %d וה'
'מספר קטן יותר הוא %d' ,
גדול יותר, קטן יותר ) ;
לַחֲזוֹר 0 ;
}
תְפוּקָה :
המספרים שאנו מוסיפים לקוד שלנו מציגים בו זמנית את הערכים הגדולים והקטנים יותר. בדרך זו, נוכל להחזיר בקלות מספר ערכים בקוד שלנו.
סיכום
מדריך זה עוסק ב'החזרת ערכים מרובים' בקודי C++. חקרנו ביסודיות רעיון זה במדריך זה ודנו בשלוש טכניקות המסייעות בהחזרת ערכים מרובים בתכנות C++. הסברנו שערכים מרובים מוחזרים על ידי שימוש בטכניקות tuples, זוגות, מצביעים וטכניקות מערך. כל הטכניקות הללו מתוארות כאן ביסודיות.