תחביר:
תבנית < כיתה ט > בָּטֵל לְהַחלִיף ( ט & משתנה_1 , ט & משתנה_2 ) ;יש להחליף גם את הערך של המשתנה הראשון וגם המשתנה השני, ששניהם מאחסנים ערכים. הפונקציה רק מחליפה את ערכי המשתנים; אין לו פלט.'
עבודה של פונקציית swap() ב-C++
פונקציית ההחלפה מיושמת ב-C++ באמצעות שלוש השורות הבאות.
תבנית בָּטֵל לְהַחלִיף ( ט & אני , ט & י ) {
טמפ' T = סטד :: מהלך \ לזוז \ לעבור ( אני ) ;
אני = סטד :: מהלך \ לזוז \ לעבור ( י ) ;
י = סטד :: מהלך \ לזוז \ לעבור ( טמפ' ) ;
}
ההצהרה 'T temp = std::move(i)'; עושה עותק של הרכיב 'i' ומשכפל אותו. כאן, 'i = std::move(j)'; משליך את הפריטים המקוריים של 'i' ומאחסן את העותק 'i' של 'j' במקום 'j' המקורי. הנוסחה 'j = std:: move(temp)'; שמור 'i' עם שיבוט של טמפ', והסר את התוכן הזהה של טמפ'. כמו כן, מחק את המשתנה temp לאחר השלמת ביצוע הפונקציה swap().
דוגמה 1: תוכנית באמצעות שיטת std::move ל-Swap
כפי שמודגם להלן, אנו יכולים להחליף שני אובייקטים באמצעות תכונת C++11 std::move.
#include
#include
תבנית
בָּטֵל לְהַחלִיף ( ט & א , ט & ב )
{
טמפ' T = סטד :: מהלך \ לזוז \ לעבור ( א ) ;
א = סטד :: מהלך \ לזוז \ לעבור ( ב ) ;
ב = סטד :: מהלך \ לזוז \ לעבור ( טמפ' ) ;
}
int רָאשִׁי ( )
{
סטד :: וֶקטוֹר רשימה = { 10 , 12 , 13 , חֲמֵשׁ עֶשׂרֵה , 16 , 17 } ;
int אני = 3 , י = 5 ;
לְהַחלִיף ( רשימה [ אני ] , רשימה [ י ] ) ;
ל ( int אני : רשימה ) {
סטד :: cout << אני << '' ;
}
לַחֲזוֹר 0 ; }
יש לנו הצהרת תבנית שיש לה אובייקט 'T'. לאחר מכן, הקמנו את הפונקציה כ'החלפה'. הפונקציה לוקחת את שני הפרמטרים &a ו-&b, מסוג 'T'. כתוצאה מהארגומנטים T& a, T& b המתייחסים או מאחסנים את הכתובת של המשתנה המועבר ומחילים ישירות עליהם מבלי לחזור, הפונקציה swap(T& a, T&b) נקראת קריאה לפי הפניה.
בתוך ה-void swap, יישמנו את האלגוריתם של החלפה באמצעות שיטת std::move. לאחר מכן, בנינו את עיקרי התוכנית. כאן, הכרזנו על המשתנה 'רשימה' ואתחלנו אותו ברשימת הערכים המספריים. קבענו את הערכים עבור 'i' ו-'j' להחלפה. הערך המספרי שנמצא במדד השני הוחלף בערך המספרי במדד החמישי. לאחר מכן, קראנו לפונקציית ההחלפה והעברנו לה את האינדקסים 'i' ו- 'j' לצורך החלפה. לולאת for משמשת להדפסת הרשימה המוחלפת.
הפלט הציג את הרשימה ששונתה. אתה יכול לראות את הרשימה החדשה שנוצרה החליפה את הערך לפי אינדקסים שצוינו.
דוגמה 2: תוכנית באמצעות שיטת std::swap להחלפה
שימוש במנגנון std::swap שנמצא בכותרת השירות (ב-C++11) הוא התיקון הרגיל. ערכי שני אובייקטים מוחלפים כדי לגרום להם לתפקד.
#include#include
#include <תועלת>
int רָאשִׁי ( )
{
סטד :: vectorarr = { 3 , 6 , 9 , חֲמֵשׁ עֶשׂרֵה , 13 } ;
int אני = 3 , י = 4 ;
סטד :: לְהַחלִיף ( arr [ אני ] , arr [ י ] ) ;
ל ( int אני : arr ) {
סטד :: cout << אני << '' ;
}
לַחֲזוֹר 0 ;
}
על ידי ייבוא קובץ הכותרת
הרשימה שהתקבלה לאחר פעולת ההחלפה באמצעות שיטת std::swap מוצגת באופן הבא:
דוגמה 3: תוכנית באמצעות שיטת std::iter_swap להחלפה
שימוש באלגוריתם std::iter_swap, המופיע בכותרת של האלגוריתם, הוא אפשרות נוספת. הדרך שבה היא פועלת היא על ידי החלפת ערכי האובייקטים שעליהם מצביעים האיטרטורים המסופקים.
#include#include
#include
#include <אלגוריתם>
int רָאשִׁי ( )
{
סטד :: vectorvec = { 64 , 61 , 62 , 63 , 60 } ;
int אני = 0 , י = 4 ;
אוטומטי itr1 = סטד :: הַבָּא ( דבר. התחל ( ) , אני ) ;
אוטומטי itr2 = סטד :: הַבָּא ( דבר. התחל ( ) , י ) ;
סטד :: iter_swap ( itr1 , itr2 ) ;
ל ( int אני : דבר ) {
סטד :: cout << אני << '' ;
}
לַחֲזוֹר 0 ;
}
לשיטה העיקרית של התוכנית, הכרזנו על משתנה וקטור 'vec' והקצנו לו רשימה וקטורית של מספרים. לאחר מכן, ציינו את מיקום האינדקס למשתנים 'i' ו-'j'. מופעלת השיטה std::iter_swap שלוקחת את iter1 ואת iter2 כארגומנט. ה-iter1 וה-iter2 מוכרזים עם מילת המפתח האוטומטית ויש להם את פעולת האיטרציה. שיטת for loop מדפיסה את הערכים המוחלפים של מערך הווקטור עם הביצוע.
שיטת std::iter_swap החליפה בהצלחה את הערכים של הוקטורים שצוינו.
דוגמה 4: תוכנית של שימוש ללא משתנים זמניים להחלפה
דוגמה זו מציגה דרך חדשה להחלפת מספרים בקוד C++ ללא שימוש במשתנים זמניים.
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
int x1 = שתיים , x2 = 12 ;
cout << 'לפני החלפה'. << endl ;
cout << 'x1 = ' << x1 << ', x2 = ' << x2 << endl ;
x1 = x1 + x2 ;
x2 = x1 - x2 ;
x1 = x1 * x2 ;
cout << ' \n לאחר ההחלפה'. << endl ;
cout << 'x1 = ' << x1 << ', x2 = ' << x2 << endl ;
לַחֲזוֹר 0 ; }
הבה נבחן את פעולת התוכנית הזו. כאן, הכרזנו על x1 ו-x2, המוגדרים בתחילה עם המספר, בהתאמה. לאחר מכן, באמצעות הנוסחה x1 = x1+ x2, נוסיף את x1 ו-x2 ונשים את התוצאה ב-x1. זה מציין ש-x1 שווה ל-2 ועוד 12. לכן, כעת שווה ל-14. לאחר מכן, אנו מיישמים את הנוסחה x2 = x1 – x2. זה מציין ש-x2 = 14 – 12. לכן, x2 שווה כעת ל-2. פעם נוספת, אנו מיישמים את הנוסחה x1 = x1 – x2. זה מציין ש-x1 = 14 – 2. לכן, x1 = 12 בסוף. כתוצאה מכך, המספרים הוחלפו.
המספר שהוחלף לפני ואחרי מוצג במסך ההנחיה הבא.
סיכום
כאן, נעבור על תיאור מלא של swap() ב-C++, השימוש בו וכמה דוגמאות המראות כיצד הוא פועל. באמצעות הפונקציה std:: swap() ניתן להחליף ערכי שני משתנים. ה-C++ STL כולל פונקציה מובנית בשם std::swap(). הפונקציה swap(T& משתנה 1, T& משתנה 2) קוראת לפי הפניה, וה-C++ עומס יתר swap() בהתאם לסוג משתני הנתונים מוסברים גם במדריך זה.