C++/מערכים: הבדלים בין גרסאות בדף

קפיצה לניווט קפיצה לחיפוש
נוספו 3,892 בתים ,  לפני 14 שנים
++
אין תקציר עריכה
 
(++)
'''מערך''' הוא מבנה נתונים בסיסי. מערך מכיל מספר מסויים של איברים מטיפוסים '''זהים'''. לדוגמה: "מערך של 100 איברים מטיפוס int" הוא אזור בזיכרון שמכיל 100 מספרים שלמים.
 
תכונה חשובה של מערכךמערך היא שהזיכרון שמוקצה עבורו הוא זיכרון רציף, כלומר חלקי המערך '''לא''' מפוזרים במקומות שונים בזיכרון אלא כל האיבירםהאיברים נמצאים בכתובות '''עוקבות'''. בדוגמה שלנו, אם גודל משתנה שלם הוא 4 בתים, אז עבור המערך יוקצה זיכרון רציף בנפח של ‎100*4=400‎ בתים. כיוון שהזיכרון הזה הוא רציף, אם נדע את הכתובת של האיבר הראשון במערך, נוכל למצוא כל איבר אחר על ידי חישוב פשוט. למשל אם הכתובת של תחילת המערך (האיבר הראשון) היא 3400, אז כתובת האיבר העשירי תהיה: ‎3400 + 4*(10 - 1) = 3436‎.
 
אין צורך לעשות חישוב זה ידנית. ב-C++‎ קיימת פעולת '''גישה לפי אינדקס''' שנדגים אותה למטה. אינדקס הוא מספרו הסידורי של האיבר במערך. חשוב לזכור שב-C++‎ אינדקס האיבר הראשון הוא 0 ולא 1, באותו אופן אינדקס האיבר השני הוא 1, העשירי הוא 9, והאחרון במערך 100 איברים הוא 99. דבר זה חוסך מהמחשב את הפחתת ה-1 שביצענו בחישוב שלמעלה. יתר על כן, התחלת הספירה מ-0 נראת טבעית יותר ככל שמקבלים יותר ניסיון בתכנות.
 
השימוש במערכים בא ביחד עם לולאות ורקורסיה (למד בהמשך על [[C++/פונקציות|פונקציות]]). אם ניצור 100 משתנים בשמות שונים, לא נוכל לעבוד עם כולם ביחד בתוך אלגוריתם אחד. כאמור במערך האיברים ממוספרים ולכן ניתן לכתוב אלגוריתמים שיעבדו מערכים ללא תלות בגודלם המעשי. למשל נוכל לכתוב אלגוריתם שמחפש את המקסימום בתוך מערך של מספרים שלמים וזה בעזרת לולאה אחת פשוטה. בדרך כלל יש תכונה שמאחדת את כל האיברים במערך מסויים. למשל בתוכנית ניהול של בית ספר, יתכן וניצור מערך של כל התלמידים עבור כל כיתה.
 
== הגדרה ==
int a[100];
</source>
גודל המערך צריך להיות קבוע שערכו ידוע בזמן ההידור. למשל נוכל, ואף עדיף, להגיד את המערך כך:
כעת נוכל לפנות לכל איבר במערך באמצעות אופרטור גישה לפי אינקס:
<source lang="cpp">
const int N = 100;
int a[N];
</source>
במקרה כזה אם נרצה לשנות את גודל המערך, נשנה רק מספר אחד.
 
== גישה לפי אינדקס ==
כעת נוכל לפנות לכל איבר במערך באמצעות אופרטור גישההגישה לפי אינקס []:
<source lang="cpp">
a[0] = 20;
a[3] = a[0]+12;
cout << a[03] << ", " << +a[30] << endl;
</source>
הפלט יהיה 42.
 
לאופרטור הגישה לפי אינדקס שני אופרנדים: הראשון שלפני הסוגריים הוא המערך עצמו, השני שנכתב בתוך הסוגריים הוא האינדקס של אליו נרצה לגשת. שני האופרנדים הם ביטויים לכל דבר, לכן נוכל לרשום בתוך הסוגריים גם, למשל, משתנה:
=== איתחול ===
<source lang="cpp">
for(int i = 0; i < N; i++)
cout << a[i];
</source>
לולאה זו מדפיסה את כל איברי המערך.
 
=== איתחול ===
על מנת לאתחל מערך נוכל להשים לתוכו את הערכים הרצויים:
<source lang="cpp">
int prime[100];
prime[0] = 2;
prime[1] = 3;
prime[2] = 5;
prime[3] = 7;
prime[4] = 11;
// ...
</source>
אבל לכתוב 100 השמות לגמרי לא נוח. קיימת דרך לאתחל את המערך בשורת הגדרתו. אחרי הסימן = (שווה) נפתח סוגריים מסולסלים שבהם נרשום את רשימת הערכים שאיתם נרצה לאתחל את המערך:
<source lang="cpp">
int primes[100] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
</source>
בשורת איתחול זו המתכנת התעצל לכתוב את כל 100 המספרים הראשוניים וכתב רק 12. הדבר לא יגרום לשגיאה, כל שאר הערכים, באינדקסים 12 עד 99 כולל, יואתחלו ל-0 אוטומטית. לעומת זאת אם נרשום בשורת האיתחול '''יותר''' איברים מגודל המערך שצויין לפני כן, המהדר יחזיר שגיאה.
 
לרוב כאשר נאתחל בדרך כזו את המערך, לא נתעניין במספר המעשי של האיברים בו. במקרה כזה נצטרך כל פעם שנשנה את איתחול המערך לספור מחדש את מספר האיברים ולעדכן את גודלו. הדבר לא נוח, לכן קיימת דרך נוספת. מותר לא לכתוב את הגודל בכלל ולהשאיר את הסוגריים ריקים. המהדבר יחשב לבד את הגודל המעשי:
<source lang="cpp">
int primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
</source>
 
נשאלת השאלה: כיצד נדע את גודל המערך בשאר התוכנית? ניתן לחשבו בעזרת האופרטור sizeof. מספר האיברים במערך שווה לגודלו בבתים חלקי גודל איבר אחד בבתים. כדי לא לעשות את החישוב בכל מקום בתוכנית, נוכל להגדיר קבוע:
<source lang="cpp">
const size_t primesCount = sizeof(primes)/sizeof(primes[0]);
</source>
 
== מערכים רב-מימדיים ==
</source>
 
== מחרוזות C ==
 
{{C++|מוגבל=כן}}
204

עריכות

תפריט ניווט