English (United Kingdom) Hebrew

קורס:"שפת C"

שיעור 7: מערכים

[ <<< הקודם ] [ תוכן עניינים ] [ הבא >>> ]

מתוך הספר: C - מדריך מקצועי       C - מדריך מקצועי
תוכן עניינים



הגדרת מערך

מערך משמש לאחסון מספר משתנים מאותו טיפוס בסדרה רצופה בזיכרון.

כל איבר במערך הוא משתנה ללא שם - ההתייחסות אליו היא באמצעות האינדקס שלו, כלומר מיקומו ביחס לתחילת המערך.

ניתן לקרוא את הערך של כל איבר במערך, לשנות את ערכו, להדפיס אותו, לקלוט לתוכו ערך מהקלט - כלומר ניתן לבצע עליו על פעולות כאילו היה משתנה פשוט.

איברי המערך יכולים להיות מטיפוס פשוט, כגון: שלם, ממשי, תו. כמו כן הם יכולים להיות מטיפוס מורכב יותר (מצביע, רשומה, מערך) כפי שנראה בהמשך.

בנוסף, טיפוס האיבר יכול להיות מוגדר משתמש (ע"י typedef) - לדוגמא, טיפוס המחרוזת String.

תחביר: הגדרת מערך דומה להגדרת משתנה, בתוספת סוגריים מרובעות וציון מספר האיברים, כלומר גודל המערך, בתוך הסוגריים:

<טיפוס-איבר>  <שם-המערך> [<גודל-המערך>];

לדוגמא, הגדרת מערך שלמים בגודל 5:

int   integers[5];

במערך מגודל n, הערכים מאוחסנים במערך החל מאינדקס 0 ועד ל- n-1. לכן המערך integers ייראה כך:

4

3

2

1

0

integers[]  =



הגישה לאיבר באינדקס i במערך מבוצעת ע"י שם המערך, בתוספת האינדקס בסוגריים:

 <שם-המערך>[i]

לדוגמא, נציב לאיבר הראשון (אינדקס 0) ערך 23, ולאיבר האחרון (אינדקס 4) ערך 11:

 
integers[0] = 23;
integers[4] = 11;
 

באופן דומה, נדפיס את האיבר שבאינדקס 3 (האיבר הרביעי) כך:

 
printf("integers[3] = %d", integers[3]);
 

נקדם הערך שבתא האחרון ב- 1:

 
integers[4]++;   /* now integers[4] is 12 */
 

תכנית למניית מספר הספרות בקלט

אם בתכנית מסויימת נרצה למנות את מספר המופעים של כל ספרה בקלט, נצטרך לשם כך 10 משתנים. יהיה נוח ופשוט יותר להשתמש במערך. נגדיר מערך שלמים בן 10 מקומות

 
          int digits[10];
 

ובכל פעם שנזהה ספרה i בקלט (0<= i <=9) נקדם את האיבר המתאים במערך ע"י:

 
          digits[i]++;
 

קוד התכנית:

 
/* file: digits.c */
#include <stdio.h>
void main ()
{
          int c,i;
        int digits[10];
          
          /* initialize array */
          for (i=0; i<10; i++)
                   digits[i]=0;
          while ((c=getchar())!=EOF)
          {
                   if (c >= '0'  &&  c <= '9')
                       digits[c-'0']++;
          }
          printf("digits=");
          for (i=0; i<10; ++i)
                   printf("%d",digits[i]);
}
 

התכנית הורצה עם הקלט הבא:

 
The 2nd wolrd war started in 1939
 

והפלט:

 
digits=0111000002
 

הסבר: ההגדרה  int digits[10] מכריזה על digits כמערך שלמים בן 10 מקומות:

 
int digits[10];
 

9

8

7

6

5

4

3

2

1

0

digits []  =

זו הסיבה שלולאת ה- for המאפסת את המערך מתחילה מ- 0 ומסתיימת מקום אחד לפני הערך המציין את גודל המערך:

 
          for (i=0; i<10; i++)
                   digits[i]=0;
 

גוף הלולאה יתבצע רק עבור ערכי i בתחום 0..9. בהגעה ל- 10 יוצאים מהלולאה ללא ביצועה. בשלב הבא נקרא תו מהקלט, וכל עוד הוא אינו סוף קובץ

 
          while ((c=getchar())!=EOF)
 

בודקים אם הוא ספרה ע"י הביטוי

 
                    if (c>='0' && c<='9')
 

הבדיקה מסתמכת על כך שבטבלת התווים במחשב מיוצגות הספרות החל ממקום מסוים ('0') ברציפות לאורך 10 מקומות (עד '9'). ראה/י טבלת תווי ASCII בנספח. לחילופין, ניתן להחליף ביטוי זה בביטוי:

 
          if (isdigit(c))
 

תוך הוספת הכללה לקובץ ctype.h. בביטוי

 
          digits[c-'0']++;
 

החיסור c-'0' נותן את אינדקס הספרה המתאימה ומקדם את הערך במערך. לדוגמא, עבור הערך c='3' תוצאת ההפרש 

 
          digits['3'-'0']++
 

היא

 
          digits[3]++
 

שמשמעותה קידום הערך שבתא 3 במערך.

אתחול מערך

ניתן לאתחל את ערכי המערך ב- 2 אופנים:

1. אתחול בהגדרה. לדוגמא, מערך ממשיים מסוג double:

 
double a[4] = {45.33, 12.21, 98.89, 2.5E10};
 

כאן מבוצעת ההצבה לאיברי המערך בזמן הגדרתו. במקרה זה ניתן גם להגדיר את המערך ללא ציון המימד, לדוגמא:

 
double a[] = {45.33, 12.21, 98.89, 2.5E9};
 

המהדר "מבין" עפ"י רשימת איברי  האתחול מהו גודל המערך המבוקש.

2. אתחול ע"י הצבה מפורשת:

 
int main()
{
double a[4];
 
a[0] = 45.33;
a[1] = 12.21;
a[2] = 98.89;
a[3] = 2.5E9;
}
 

כאן אנחנו מציבים ערכים במפורש לתאי המערך a :

3

2

1

0

a[]  =

2.5E9

98.89

12.21

45.33

בדרך כלל פעולות על מערכים מבוצעות בלולאות. לדוגמא, התכנית הבאה מגדירה מערך גלובלי:

 
#include <stdio.h>
 
#define ARRAY_SIZE      7
int array[ARRAY_SIZE]; /* define a  global array */
 

המערך מוגדר ע"י קבוע קדם-מעבד. ניתן כעת לכתוב פונקציה לאיתחול המערך מהקלט:

 
void input()
{
          int i;
          for (i=0; i<ARRAY_SIZE; i++)
          {
               scanf("%d",&array[i]);
          }
}
 

הסבר: הפונקציה עוברת בלולאה על איברי המערך הגלובלי וקוראת ערכים לתוכו ע"י

 
               scanf("%d",&array[i]);
 

array[i] הוא האיבר ה- i במערך, והקידומת & מציינת את כתובתו עבור scanf. הרצה לדוגמא של הפונקציה הנ"ל עם הקלט:

 
2 7 -1 0 19 666 -29
 


תרשים המערך לאחר ביצוע הפונקציה:

6

5

4

3

2

1

0

array []  =

-29

666

19

0

-1

7

2

כללים

  • ערכי המחדל של איברי מערך באיתחול הם עפ"י הכללים של משתנים פשוטים: אם המערך מוגדר כמקומי בפונקציה, ערכי איבריו לא מוגדרים ("זבל"). אם הוא מוגדר כגלובלי, האיברים הם בעלי ערך 0.
  • גם מבחינת משך הקיום וטווח ההכרה (scope) הכללים לגבי המערך הם בדומה למשתנים פשוטים. ראה/י פרק 6, סעיף "משתנים ופונקציות".

פעולות על מערכים

מציאת ערך מקסימום

הפונקציה find_max המובאת בעמ' 170 מוצאת ומחזירה את המספר הגדול ביותר במערך.

בדיקת קיום של ערך מסוים במערך

הפונקציה exist המובאת בעמ' 170 בודקת קיום של ערך הניתן לה כפרמטר במערך.

מיון איברי המערך - שיטת מיון "בועות"

כדי למיין את איברי המערך נגדיר פונקציה בשם sort שתבצע את המיון ע"י שיטת מיון בועות (Bubble sort).

בשיטה זו משווים בין כל 2 איברים סמוכים ואם יש צורך מחליפים בין ערכיהם.

לדוגמא, נניח שנתון מערך של 7 שלמים עם הערכים הבאים:

6

5

4

3

2

1

0

12

-5

100

17

21

5

8

אנו מעוניינים למיין את המערך בסדר עולה. נבצע את המיון בלולאה עם מספר חזרות. חזרה ראשונה:

  - משווים בין איבר 0 ואיבר 1

6

5

4

3

2

1

0

12

-5

100

17

21

5

8

  - מכיוון ש- 8 גדול מ- 5 מחליפים בין ערכי האיברים:

6

5

4

3

2

1

0

12

-5

100

17

21

8

5

  - משווים בין איבר 1 ואיבר 2

6

5

4

3

2

1

0

12

-5

100

17

21

8

5

    
    מכיוון ש- 8 קטן מ- 21 לא מבצעים החלפה.

  - משווים בין איבר 2 ואיבר 3

6

5

4

3

2

1

0

12

-5

100

17

21

8

5

  - מכיוון ש- 21 גדול מ- 17 מחליפים בין ערכי האיברים:

6

5

4

3

2

1

0

12

-5

100

21

17

8

5

  - השוואה בין איברים 3,4 - אין החלפה:

6

5

4

3

2

1

0

12

-5

100

21

17

8

5

  - השוואה בין איברים 4,5 והחלפה:

6

5

4

3

2

1

0

12

100

-5

21

17

8

5

                                   

  - השוואה בין איברים 5,6 והחלפה:

6

5

4

3

2

1

0

100

12

-5

21

17

8

5

כפי שניתן לראות, בסוף החזרה הראשונה נמצא האיבר המקסימלי (100) בסוף המערך.

בחזרה השנייה יש לבצע כנ"ל על 5 האיברים הראשונים בלבד:

  - השוואה בין איברים 0,1 - אין החלפה:

6

5

4

3

2

1

0

100

12

-5

21

17

8

5

  - השוואה בין איברים 1,2 - אין החלפה:

6

5

4

3

2

1

0

100

12

-5

21

17

8

5

  - השוואה בין איברים 2,3 - אין החלפה:

6

5

4

3

2

1

0

100

12

-5

21

17

8

5

  - השוואה בין איברים 3,4  והחלפה:

6

5

4

3

2

1

0

100

12

21

-5

17

8

5

  - השוואה בין איברים 4,5 והחלפה:

6

5

4

3

2

1

0

100

21

12

-5

17

8

5

בסוף החזרה השנייה נמצא האיבר השני בגדלו (21) במקומו. באופן זהה ממשיכים בביצוע חזרות עד למיון המלא של המערך.

שמו של אלגוריתם מיון זה בא לו מתכונה זו: בכל שלב מוצף האיבר המקסימלי לסוף המערך בדומה לבועה.

שאלה: כמה חזרות נדרשות למיון מערך בגודל n ?

תשובה: מכיוון שבכל חזרה מוצף איבר אחד למקומו, אזי במקרה הגרוע ביותר - האיבר המינימלי נמצא בסוף המערך - נצטרך n-1 חזרות להזזתו מהסוף להתחלה.

נראה כעת מימוש של מיון בועות ע"י הפונקציה sort:

 
/* sort the array in ascending order */
void sort()
{
          int i,j;
          int temp;
 
          for(i=0; i<ARRAY_SIZE - 1; i++) 
          {
                   for(j=0; j<ARRAY_SIZE - 1 - i; j++) 
                   {
                            if(array[j] > array[j+1]) 
                            {
                                      temp = array[j];
                                      array[j] = array[j+1];         
                                      array[j+1] = temp;
                            }
                   }
          }
}
 

הפונקציה מבצעת מעבר בלולאה כפולה על איברי המערך:

  - בלולאה החיצונית מבצעים n-1 חזרות.
  - בלולאה הפנימית עוברים עפ"י הסדר על כל אחד מאיברי המערך (עד לאיבר שלפני האחרון), משווים אותו לאיבר העוקב לו ומחליפים ביניהם אם יש צורך. 

באופן כללי, אחרי החזרה ה- i -ית האיבר ה- i בגדלו נמצא במקומו. לכן, בלולאה הפנימית אין צורך לעבור ולהשוות את כל האלמנטים - די לעבור על מספר האלמנטים פחות i.

התכנית במלואה מובאת בעמ' 174-176 וכוללת את הפונקציות:

  • input() - פונקציה לאתחול איברי המערך מהקלט
  • output() - פונקציה להדפסת איברי המערך לפלט
  • find_max() - פונקציה המוצאת ומחזירה את ערך האיבר המקסימלי במערך
  • exist() - פונקציה המחזירה ערך אמת אם ערך נתון קיים במערך, שקר אחרת
  • sort() - פונקציה המבצעת מיון של המערך בשיטת "בועות"
  • main() - הפונקציה הראשית בתכנית. פונקציה זו קוראת לשאר הפונקציות ו"מנהלת" את מהלך התכנית.


העברת מערך כפרמטר לפונקציה ושיקולי מודולריות

בתכנית האחרונה הגדרנו את המערך כמשתנה גלובלי כדי לאפשר שיתופו בין מספר פונקציות. לו היינו מגדירים אותו כמקומי בפונקציה main למשל, הוא לא היה מוכר בפונקציות האחרות.

כאשר מועבר נתון פשוט כפרמטר לפונקציה נוצר שיכפול שלו בפונקציה הנקראת. שינוי ערכו בפונקציה זו לא משפיע על ערכו אצל הפונקציה הקוראת.

לעומת זאת מערכים המועברים כפרמטרים לא משוכפלים בפונקציה הנקראת. הפונקציה מתייחסת לאותו מקום בזיכרון בו הוגדר המערך בפונקציה הקוראת.

לדוגמא, הפונקציה הראשית בתכנית הבאה מעבירה את המערך כפרמטר לפונקציה המקדמת את ערכי כל איברי המערך ב- 1 :

 
#include <stdio.h>
void increment_array(int arr[], int size)
{
          int i;
          for(i=0; i<size; i++)
                   arr[i]++;
}
 
void main()
{
          enum { ARRAY_SIZE=5 };
          int array[ARRAY_SIZE] = {6,9,2,5,18};
          int i;
 
        increment_array(array, ARRAY_SIZE);
          for( i=0; i<ARRAY_SIZE; i++)
                   printf("%d ", array[i]);
}
 

פלט התכנית:

 
7 10 3 6 19
 

הסבר: הפונקציה increment_array() מבצעת קידום של כל איברי מערך השלמים ב- 1. לצורך כך, היא מקבלת את המערך ואת גדלו כפרמטרים:

 
void increment_array(int arr[], int size)
{
          int i;
          for(i=0; i<size; i++)
                   arr[i]++;
}
 

הפונקציה increment_array() פועלת על המשתנה הפורמלי arr, המצביע למערך האקטואלי שמועבר בפונקציה הקוראת main(). הפונקציה עוברת על כל איבריו ומקדמת אותם ב- 1.

הפונקציה הקוראת, main(), מגדירה את המערך array כמקומי. לצורך ציון גדלו, מוגדר הקבוע ARRAY_SIZE כ- enum :

 
          enum { ARRAY_SIZE=5 };
          int array[ARRAY_SIZE] = {6,9,2,5,18};
 
הערה : כאשר מציינים גודל מערך בשפת C, חובה לציין קבוע מספרי (ליטרל), קבוע שהוגדר ע"י קדם-המעבד (pre-processor) או קבוע שהוגדר ע"י enum. לא ניתן לציין כגודלו של המערך קבוע שהוגדר ע"י const.

בהמשך, מבצעים קריאה לפונקציה increment_array תוך העברת המערך וגדלו כפרמטרים:

 
          increment_array(array, ARRAY_SIZE);
 

לבסוף מודפסים איברי המערך:

 
          for( i=0; i<ARRAY_SIZE; i++)
                   printf("%d ", array[i]);
 

פונקציות מודולריות

העברת המערך כפרמטר לפונקציה היא שיטת תכנות מודולרית יותר ועדיפה על פני הגדרתו כמשתנה גלובלי ממספר סיבות:

  • ניתן לבצע שימוש חוזר בפונקציה המקבלת את המערך כפרמטר עבור מספר מערכים.
  • המעטה במספר המשתנים הגלובליים מקילה על ניפוי התכנית, כלומר מציאת השגיאות בזמן הריצה.

נחזור לתכנית המטפלת במערכים: נגדיר את המערך כמקומי ב- main, שתעביר אותו לשאר הפונקציות כפרמטר -

 
/* file: array2.c */
#include <stdio.h>
 
  - הגדרת הפונקציות:
 
/* initialize the array by input from the user */
void input(int arr[], int size)
{
          int i;
 
          printf("\nEnter %d numbers:", size);
          for (i=0; i<size; i++)
          {
                   scanf("%d",&arr[i]);
          }
}
 
/* output array elements  */
void output(int arr[], int size)
{
          int i;
 
          printf("\nArray elements:");
          for (i=0; i<size; i++)
          {
                   printf("%d\t",arr[i]);
          }
}
...
 
  - הפונקציה main() :
 
int main()
{
        enum {ARRAY_SIZE=7};
          int num;
        int array[ARRAY_SIZE];
 
          /* initialize the array */
          input(array, ARRAY_SIZE);
          
          /* find max number in the array */
          printf("\nThe maximum number is %d", find_max(array, ARRAY_SIZE));
          
          /* is a given number exist in the array */
          printf("\nEnter a number to find in the array:");
          scanf("%d",&num);
          if(exist(array, ARRAY_SIZE, num))
                   printf("\nThe number %d exist in the array", num);
          else
                   printf("\nThe number does not exist in the array");
 
          /* sort the array */
          printf("\nSorting the array...");
          sort(array, ARRAY_SIZE);
          output(array, ARRAY_SIZE);
          return 0;
}
 

יש לשים לב לנקודות החשובות בגירסה זו של התכנית:

  • המערך מוגדר כמקומי בפונקציה main ומועבר כפרמטר לפונקציות השונות.
  • גודל המערך - הקבוע ARRAY_SIZE - מוגדר באופן מקומי בפונקציה main ע"י enum והוא אינו מוכר מחוץ לה. באופן זה מרחב השמות (namespace) הגלובלי אינו מזוהם.

מערכים רב-ממדיים

ניתן להגדיר מערך ממספר ממדים. לדוגמא, הגדרת מערך דו-ממדי בגודל 5 על 10 :

 
int    matrix[5][10];
 

המימד הראשון המצוין, 5, הוא מימד השורות והמימד השני, 10, הוא מימד העמודות:

 

לדוגמא, תכנית המדפיסה מטריצה שבאלכסונה הראשי '1' -ים ובכל שאר איבריה אפסים:

 
/* file: matrix.c */
#include <stdio.h>
#define LINES_NO           5
#define COLUMNS_NO    10        
 
void main()
{
          char matrix[LINES_NO][COLUMNS_NO];
          int    i,j;
 
          for(i=0; i<LINES_NO; i++) 
                   for(j=0; j<COLUMNS_NO; j++)
                            if(i==j)
                                      matrix[i][j] = '1';
                            else
                                      matrix[i][j] = '0';
 
          for(i=0; i<LINES_NO; i++) 
          {
                   for(j=0; j<COLUMNS_NO; j++)
                            putchar(matrix[i][j]);
                   putchar('\n');
          }
}
 

פלט התכנית:

 
1000000000
0100000000
0010000000
0001000000
0000100000
 

אתחול מערך רב-ממדי

כמו מערך חד-ממדי, ניתן לאתחל מערך רב ממדי ע"י לולאה כנ"ל או ע"י אתחול בהגדרה. דוגמאות:

1. מטריצת ממשיים בגודל 2x3 :

 
float  matrix1[][3] = { {1.0, 1.5, 2.0}, {3.0,3.5,4.0}};
 

ציון המימד הראשון אופציונלי, את השני חובה לציין.

2. מערך תווים תלת-ממדי בגודל 2x2x3 :

 
char  array3D[][2][3] = { {{'1', '2', '3'}, {'a', 'b', 'c'}},   {{'4','5','6'},{'e','f','g'}} };
 

המימד הראשון הוא אופציונלי, את השני והשלישי חובה לציין. ככלל, אתחול בזמן הגדרה מחייב לציין את n-1 הממדים האחרונים של מערך ממימד n.

העברת מערך רב-ממדי כפרמטר לפונקציה

אם מערך דו-ממדי מוגדר כך:

 
float  array[3][4];
 

פונקציה המקבלת אותו כפרמטר תוגדר כך:

 
void func(float array[][4]);
 

או כך:

 
void func(float array[3][4]);
 

ציון המימד הראשון הוא אופציונלי, אולם את המימד השני של המערך חובה לציין כדי שהמהדר ידע כיצד לתרגם בפונקציה func את האינדקסים. לדוגמא:

 
void func(float array[][4])
{
          array[1][3] = 4.56f;    
}
 

מערך רב-ממדי מיוצג בשפת C ע"י פרישתו למערך חד-ממדי:

2-3

2-2

2-1

2-0

1-3

1-2

1-1

1-0

0-3

0-2

0-1

0-0

array[]  =

4.56



המהדר חייב לדעת שמימד העמודות של המערך הוא 4 כדי לדעת את מיקום האיבר array[1][3].

כלומר, מיקום האיבר array[1][3] בפונקציה שמגדירה את המימד השני של המערך כ- 4 מחושב ע"י array[1*4 + 3].

בתכנית הדוגמא המובאת בעמ' 181 כוללת שני מערכים דו-מימדיים (מטריצות) של תווים:

עיין/י בקוד התכנית.

מיון שורות ועמודות מערך רב-ממדי

לשורות של מטריצה ניתן להתייחס כאל מערך רגיל מכיוון שהמטריצה נפרשת בזיכרון למערך חד ממדי שורה-שורה. לדוגמא, נניח שמוגדרת המטריצה הבאה:

 
          #define COLUMNS_NO 3
          
          char matrix[4][COLUMNS_NO] = 
                   {{'f', 'a', 'h'} ,{'w', 'c', 'k'}, {'g', 'o', 'l'}, {'d', 'j', 'i'}};
 

פונקציה למיון שורה אחת מהמטריצה ניתן לכתוב כך:

 
void sort_line(char line[], int columns_no)
{
          int    i,j;
          char temp;
          
          for(i=0; i<columns_no - 1; i++)
                   for(j=0; j<columns_no-1-i; j++)
                            if(line[j] > line[j+1])
                            {
                                      temp = line[j];
                                      line[j] = line[j+1];
                                      line[j+1] = temp;
                            }
}
 

מתוך התכנית המשתמשת הפונקציה תיקרא כך, למשל:

 
sort_line(matrix[2], COLUMNS_NO);
 

קריאה זו תגרום למיון שורה 2 במטריצה.

תרגיל: מה יבוצע אם במקום הפרמטר COLUMNS_NO יועבר לפונקציה sort_line הערך 6:

sort_line(matrix[2], 6);

מיון עמודות

בפונקצית המיון של העמודות, הואיל והם לא נפרשים באופן רציף בזיכרון - יש לקבל כפרמטר את המטריצה, את מספר השורות הכולל ואת אינדקס העמודה למיון:

פונקצית המיון של עמודה במטריצה:

 
void sort_column(char matrix[][COLUMNS_NO], int lines_no, int col)
{
          int    i,j;
          char           temp;
          
          for(i=0; i<lines_no - 1; i++)
          {
                   for(j=0; j<lines_no-1-i; j++)
                   {
                            if(matrix[j][col] > matrix[j+1][col])
                            {
                                      temp = matrix[j][col];
                                      matrix[j][col] = matrix[j+1][col];
                                      matrix[j+1][col] = temp;
                            }
                   }
          }
}
 

והפונקציה תיקרא כך, למשל:

 
sort_column(matrix, 41);
 

הוראה זו תגרום למיון עמודה 1 במטריצה. יש לשים לב שגודל העמודות חייב להיות ידוע לפונקציה, בכדי שהיא תתורגם נכון, לכן מספר העמודות מוגדר כקבוע ומצוין כמימד שני. לעומת זאת, מספר השורות מועבר כפרמטר.

תכנית המיון הכוללת

קוד תכנית המיון הכוללת מובאת בעמ'  185-187.

סיכום

  • מערך בגודל n הוא אוסף איברים מטיפוס זהה המסודרים ברציפות בזיכרון מאינדקס 0 ועד אינדקס n-1. ניתן להגדיר מערך ממספר ממדים.
  • איברי המערך ניתנים לגישה ע"י ציון שם המערך בצירוף האינדקס בסוגריים מרובעות [].
  • ניתן לאתחל מערך ע"י מעבר על האיברים בלולאה ובהצבת ערכים מתאימים או ע"י אתחול בהגדרה.
  • פעולות על איברי המערך מבוצעות בדרך כלל בלולאות:
  - מציאת ערך מקסימום
  - בדיקה אם ערך מסוים קיים במערך
  - מיון
  • מערך רב ממדי הוא מערך בעל מספר ממדים. ניתן להגדיר מערך ב- C ממספר לא מוגבל של מימדים, והוא מיוצג בזיכרון ע"י פרישתו כמערך חד-ממדי. חובה לציין את n-1 הממדים האחרונים של מערך בעל n ממדים באתחולו ובהעברתו כפרמטר לפונקציה.

תרגילי סיכום

בצע/י את תרגילי הסיכום שבעמ' 188.



[ <<< הקודם ] [ תוכן עניינים ] [ הבא >>> ]