ממאמר זה תוכלו למצוא את ההבדלים בין שתי הפונקציות הללו ולהבין כיצד הן פועלות.
shuffle() ב-C++
ה לְעַרְבֵּב() function היא פונקציית C++ מובנית המשמשת לערבב אקראי או לסדר מחדש את האלמנטים בטווח נתון. הפונקציה מוצהרת ב- <אלגוריתם> header ויש לו שני ארגומנטים: מיקום ההתחלה של הטווח הוא הארגומנט הראשון, והארגומנט השני מייצג את מיקום הסיום.
בנוסף, הוא גם דורש פרמטר שלישי אופציונלי, שהוא אובייקט פונקציה שיוצר מספרים אקראיים שישמשו לערבב את האלמנטים בטווח.
כאשר לְעַרְבֵּב() הפונקציה נקראת, היא מסדרת מחדש באופן אקראי את האלמנטים בטווח שצוין באמצעות מחולל המספרים האקראיים שסופק. התוצאה של הדשדוש אינה ניתנת לחיזוי, וכל שינוי אפשרי של האלמנטים צפוי להתרחש באותה מידה.
דוגמא
שקול את הדוגמה הבאה לשימוש ב- פונקציית shuffle() ב-C++. בתוכנית זו, יצרנו את הווקטור דבר עם הערכים השלמים של 0 עד 10. לאחר מכן אנו יוצרים מחולל מספרים אקראיים, אשר מועבר יחד עם הטווח של הווקטור ל- לְעַרְבֵּב() פוּנקצִיָה. ה לְעַרְבֵּב() הפונקציה לוקחת את המספר ומחליפה את האלמנטים על סמך המספר הזה. לאחר מכן הדפסנו את רצף הווקטור המאורגן מחדש באמצעות לולאת for
#include
#include
#include <אלגוריתם>
#include <אקראי>
#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
וֶקטוֹר < int > דבר { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } ;
לא חתום זֶרַע = כרונו :: שעון מערכת :: עַכשָׁיו ( ) . זמן_מאז_תקופה ( ) . לספור ( ) ;
לְעַרְבֵּב ( דבר. התחל ( ) , דבר. סוֹף ( ) , default_random_engine ( זֶרַע ) ) ;
cout << 'אלמנטים ערבובים הם:' ;
ל ( int & אני : דבר )
cout << '' << אני ;
cout << endl ;
לַחֲזוֹר 0 ;
}
random_shuffle() ב-C++
ה random_shuffle() הפונקציה גם מסדרת מחדש באופן אקראי את האלמנטים בטווח הנתון עם מספר שנבחר באקראי. הוא משתמש במחולל מספרים אקראיים כדי ליצור רצף של מספרים אקראיים ולאחר מכן משתמש במספרים האלה כדי לערבב את האלמנטים בטווח, כך שרצף התוכנית יהיה שונה בכל פעם שתפעיל את התוכנית.
נדרשים שני פרמטרים עבור random_shuffle() : מיקום ההתחלה של הטווח הוא הפרמטר הראשון, והפרמטר השני הוא מיקום הסיום. בנוסף, random_shuffle() יכול לקחת פרמטר שלישי אופציונלי, שהוא אובייקט פונקציה שניתן להשתמש בו כדי ליצור את המספרים האקראיים לערבב את האלמנטים.
דוגמא
הדוגמה שלהלן ממחישה את פעולתו של random_shuffle() ב-C++. בקוד זה, יצרנו א דבר וקטור עם ערכי מספרים שלמים מ-1 עד 10 ולאחר מכן השתמש ב- עבור לולאה כדי להדפיס את הרצף המעורב באקראי:
#include#include <אלגוריתם>
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
וֶקטוֹר < int > דבר { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 } ;
srand ( static_cast < לא חתום int > ( זְמַן ( nullptr ) ) ) ;
אקראי_ערבב ( דבר. התחל ( ) , דבר. סוֹף ( ) ) ;
ל ( int אני : דבר ) {
cout << אני << '' ;
}
cout << ' \n ' ;
לַחֲזוֹר 0 ;
}
ההבדל בין shuffle() ל-random_shuffle()
להלן ההבדלים העיקריים ביניהם לְעַרְבֵּב() ו random_shuffle() פונקציות ב-C++.
1: random_shuffle() לוקח זוג איטרטורים המייצגים את טווח האלמנטים לערבב, בעוד לְעַרְבֵּב() לוקח זוג איטרטורים המייצגים את טווח האלמנטים לערבב, כמו גם מחולל מספרים אקראיים לשימוש עבור ערבוב.
2: random_shuffle() בדרך כלל פחות יעיל מ לְעַרְבֵּב() , מכיוון שעליו ליצור רצף של מספרים אקראיים לשימוש לערבוב.
3: random_shuffle() משתמש ביישום הפנימי של הספרייה הסטנדרטית של C++ של מחולל המספרים האקראיים כדי לערבב את האלמנטים, תוך כדי לְעַרְבֵּב() מאפשר לך לציין את מחולל המספרים האקראיים שלך לשימוש עבור ערבוב, מה שנותן לך שליטה רבה יותר על האקראיות של הערבול.
4: random_shuffle() הוצג ב-C++98 והוא נתמך על ידי כל הגרסאות של הספרייה הסטנדרטית C++, בעוד לְעַרְבֵּב() הוצג ב-C++11 והוא נתמך רק על ידי מהדרים שמיישמים את הגרסה הזו של התקן.
מחשבות אחרונות
הבחירה בין לְעַרְבֵּב() ו random_shuffle() תלוי במקרה השימוש והדרישות הספציפיות שלך. אם אתה צריך יותר שליטה על האקראיות של הדשדוש, או אם אתה רוצה להשתמש במחולל מספרים אקראיים מותאם אישית, אז לְעַרְבֵּב() תהיה בחירה טובה יותר. מצד שני, אם אתה לא צריך את רמת השליטה הזו ורק רוצה דרך פשוטה לערבב אלמנטים, אז random_shuffle() יכול להספיק.