Introduction to Programming in C

Introduction to Programming in C תרגול 7 01.04.2011 1 1

נושאים • מצביעים • רקע • אופרטורים על מצביעים • מצביעים כפרמטרים לפונקציה • הקצאת זיכרון דינאמית • Malloc • free

מצביעים תאור הזיכרון של המחשב: ניתן לחשוב על זיכרון המחשב כעל רצף של תאים, כל אחד בגודל בית (byte) כאשר כל בית בגודל של 8 סיביות (bits). כל תא בזיכרון מזוהה ע"י ערך מספרי המתאר את מיקומו המדוייק. ערך זה הינו הכתובת של התא בזיכרון (memory address). למשל, אם נגדיר את המשתנים הבאים: char var1; // storage for type char is 1 byte. double var2; // storage for type char is 8 byte. int var3; // storage for type char is 4 byte. כתובת של משתנה הינה הכתובת של הבית הראשון ברצף הבתים שמשתנה זה תופס בזיכרון. ברגע שנצהיר על משתנים כמצביעים, נוכל להציב לתוכם כתובות של משתנים.לדוגמא: int x = 200 ; int p; /*Declaration of a pointer “p” that is of type “int *”.*/ p=&x; /*Assign the address of “x” to be the value of “p”.*/ בשלב זה המשתנה p מכיל את הכתובת של המשתנה x.

אופרטורים מצביעים האופרטור & אם x הוא משתנה אזי &x היא כתובת הזיכרון של x,כלומר האופרטור & מציין "כתובתו של…". מצביעים (pointers): מצביע הינו משתנה שהערך שלו הוא כתובת שלמשתנה כלשהו. במילים אחרות, מצביע הינו משתנה שמצביע למשתנה אחר. אם נרצה להגדיר את p כמצביע למשתנה כלשהו מטיפוסint , שורת ההצהרה תיראה כך: int *p; באופן כללי, תבנית הצהרה על מצביעים הינה: <variable-type> *<variable name>; האופרטור  האופרטור  הינו אופרטור שפועל על מצביעים. למשל עבור הדוגמה הקודמת *p שקול ל-x. כלומר *p הוא התוכן של תא הזיכרון ש-p מצביע עליו.

דוגמאות int x = 200 ; int p; /*Declaration of a pointer “p” that is of type “int *”.*/ p=&x; /*Assign the address of “x” to be the value of “p”.*/ p=500; // < שקול==> x=500;. זהירות בעת שימוש במצביעים: כשמצהירים על מצביע p אין הוא בהכרח מצביע על ערך חוקי! int *pi; *pi = 100; /*wrong!!!!*/ טעות זו ידועה בשם segmentation fault ,זוהי אינה שגיאת קומפילציה, אלא, שגיאה בזמן ריצה.

העברת מצביעים כפרמטרים לפונקציה מכיוון שמצביעים הם משתנים לכל דבר, ניתן להעביר את ערכיהם בתור פרמטרים לפונקציות. מנגנון זה מאפשר לפונקציה נקראת לשנות את ערכיהם של משתנים בסביבה הקוראת. לדוגמא ,נכתוב פונקציה אשר מחליפה בין ערכיהם של זוג משתנים מטיפוס int: void swap(inta, intb){ inttmp = a; a =*b; *b = tmp; } כתובת של מערך שמו של מערך דומה למצביע המייצג את הכתובת של האיבר הראשון בתוך המערך. על אף הדמיון, חשוב לזכור ששם של מערך אינו מצביע שכן הוא מייצג כתובת קבועה, לא ניתן לשנותה במהלך התוכנית.

דוגמא נוספת #include <stdio.h> void main(){ int x , *px; /*Define a variable of type int named "x" and a variable of type pointer to int named "px".*/ int y, *py ; px=&x; /*Assign the address of "x" to be the value of "px".*/ py=&y; scanf("%d%d",px,py); /*Read two integers values from the input and assign them to "x" and "y". Make sure that you understand why!!! */ printf("x=%d , y=%d\n",*px,*py); /*Print the values of the x and y which are the variables pointed to by px and py. */

תרגיל 1 שאלה 1: נתונה השורה הבאה של תכנית בשפת C: int a, *b, c[4]; סמנו את כל ההוראות שאינן יכולות להופיע באופן חוקי בהמשך התכנית. הוראה חוקית היא הוראה נכונה מבחינה תחבירית שעוברת קומפילציה. א) *(c+3) = 8; ב) a = *(c + *b); ג) *(c++) = 12; ד) c = b; ה) b = c; ו) a = (*c)++; ז) *(b+1) = (*c)++; ח) a = *b - *c; ט) *c = *(b++); י) *(b++)= *(&a); יא) *b==2=a; יב) c[3] = *b == 2;

תרגיל 1 שאלה 1: נתונה השורה הבאה של תכנית בשפת C: int a, *b, c[4]; סמנו את כל ההוראות שאינן יכולות להופיע באופן חוקי בהמשך התכנית. הוראה חוקית היא הוראה נכונה מבחינה תחבירית שעוברת קומפילציה. א) *(c+3) = 8; // c[2]=8; ב) a = *(c + *b); ג) *(c++) = 12; /*Compilation Error: error C2105: '++' needs l-value*/ ד) c = b; /*Compilation Error: error C2106: '=' : left operand must be l-value*/ ה) b = c; ו) a = (*c)++; ז) *(b+1) = (*c)++; ח) a = *b - *c; ט) *c = *(b++); י) *(b++)= *(&a); יא) *b==2=a; /*Compilation Error: error C2106: '=' : left operand must be l-value*/ יב) c[3] = *b == 2;

תרגיל 2 תוכנית לחישוב אורך המחרוזת עם שימוש במצביעים: #include <stdio.h> #define MAX_LENGTH 80 int my_strlen (char *s){ char *p = s; while (*p) p++; return p - s; } void main(){ char str[MAX_LENGTH]; int len; printf("Enter a string:"); gets(str); len = my_strlen(str); printf("The lenght of the string %s is %d \n",str,len); }

תרגיל 3 תוכנית לחיבור 2 מחרוזות הממחישה שימוש במצביעים: #include <stdio.h> #include <string.h> #define MAX_LENGTH 81 /*Option #1*/ void stringCat(char *s1, char *s2){ while (*s1 ) ++s1; /*We could equivalently have written: s1++; */ do } *s1 = *s2; s1++; s2++; } while(*s2); *s1 = '\0'; } /*Option #2*/ void stringCat(char *s1, char *s2){ while (*s1 ) ++s1; while(*(s1++) = *(s2++)); {

המשך תרגיל 3 /*Option #3*/ void stringCat(char *s1, char *s2){ strcpy(s1+strlen(s1),s2); } void main(){ char str1[MAX_LENGTH], str2[MAX_LENGTH]; printf("Enter a string #1 with maximum %d characters:",(MAX_LENGTH-1)/2); gets(str1); printf("Enter a string #2 with maximum %d characters:",(MAX_LENGTH-1)/2); gets(str2); stringCat(str1,str2); /*We can use any (but not more than one) of the options above! */ printf("The final string is \"%s\" \n",str1); }

תרגיל 4 כתוב פונקציה char * strstr(char *st1, char *st2) שמקבלת כארגומנט שתי מחרוזות. במידה שהמחרוזת st2 מוכללת במחרוזתst1 , הפונקציה מחזירה מצביע לתו של st1 שממנו מתחילה המחרוזת הזאת, אחרת הפוקציה מחזירה NULL. #include <stdio.h> #include <stdlib.h> char * iterStrstr(char *st1, char *st2){ char *p1,*p2; int len2 = strlen(st2); int len1 = strlen(st1); while (len1>=len2){ for(p1=st1,p2=st2;*p2 && *p1==*p2;p1++,p2++); if(!*p2) return st1; st1++; len1--; } return NULL; }

המשך תרגיל 4 void main(){ char st1[]="bnbnbacdhghg",st2[]="acd"; char *c; if(c= strstr(st1,st2)) printf ("The first character in both st2 and st1 is %c\n ",*c); else printf ("Sorry, st2 isn't contained in st1!!!\n"); {

זיכרון דינמי ישנן שתי שיטות לביצוע הקצאת זיכרון: הקצאת זיכרון סטטית והקצאת זיכרון דינאמית.הקצאת זיכרון סטטית - המהדר קובע את דרישות האחסון על פי הצהרת המשתנים, בזמן הקומפילציה (כך הקצאנו זיכרון עד כה!). בעיה שלעיטים צצה היא שאין אנו יכולים לנחש מראש את כמות הזיכרון שהתוכנית שלנו עלולה לצרוך. הקצאת זיכרון דינאמית - הקצאת מקום נעשה בזמן בריצה על יד קריאה לפונקציה malloc() (קיצור ל-memory allocation). פונקציה זו מקבלת כפרמטר את מס' הבתים שברצונינו להקצות ומחזירה את הכתובת של הבית הראשון ברצף הבתים שהקצאתה. אם הפונקציה נכשלת מוחזר הערך NULL. שחרור זיכרון דינאמית - מכיוון שהקצאת הזיכרון נעשתה בזמן ביצוע התוכנית, יש לדאוג לשחרר את הזיכרון לאחר שנסיים להשתמש בו. שיחרור של זיכרון דינאמי נעשה ע"י קריאה לפונקציה free(). הפונקציה מקבלת מצביע לכתובת תחילת קטע הזיכרון שרוצים לשחרר.

אופרטורים האופרטור sizeof האופרטור sizeof מחזיר את גודלו של הטיפוס בבתים. תבנית:sizeof (name_of_charecter) לדוגמא:sizeof (float) מחזיר 4. אילו הינו כותבים: float f; sizeof(f) היה מחזיר את אותו דבר (4). שימוש בפונקציה malloc: variable_pointer = (pointer_type) malloc (size_of_memory); דוגמא: int size, *p_list; printf("Enter the number of elements:"); scanf("%d", &size); p_list = (int*)malloc (size * sizeof(int));

דוגמא להקצאת ושחרור זיכרון כאשר מקצים זיכרון הערך המוחזר על ידי פונקצית הקצאת זיכרון היא כתובת. יש מקרים שבעבורם הקצאת הזיכרון נכשלת והערך המוחזר על ידי הפונקציה הוא null. מכיוון שלא קיבלנו כתובת לא ניתן להשתמש במצביע כמצביע "חוקי" ונרצה לסיים את התוכנית. לכן לאחר הקצאת זיכרון תמיד צריך לבדוק האם ההקצאה הצליחה. void main(){ long *l_list;l_list =(long*) malloc (5*sizeof(long)); if (l_list == NULL){printf ("Failed to allocate memory"); return; } free(l_list);}

תרגיל 5 תוכנית להדגמה של מערך דו-מימדי דינאמי: כשרוצים להגדיר מערך דו מימדי בעל גודל משתנה, עלינו ליצור מערך של מצביעים למערכים. גודל המערך לא ידוע בתחילת התכנית ולכן נגדיר את המערך באמצעות פונקצית malloc(). בתחילה נאתחל מערך של מצביעים, ולאחר מכן נאתחל כל מצביע להיות מערך של ה- type הרצוי. למשל, יצירת מערך של int-ים בגודל המוגדר ע"י המשתמש שבכל איבר בו יש את הערך של מכפלת האינדקסים שלו: #include <stdio.h> #include <stdlib.h> void main(){ inti,j,rows,cols,t; int **array; printf("enter num of rows: "); scanf("%d",&rows); printf("enter num of columns: "); scanf("%d",&cols); if (!(array=(int **)malloc(rows*sizeof(int *)))){ printf("Memory allocation failed, quiting… "); return; } . . .

המשך תרגיל 5 for (i=0;i<rows;i++) } /*Fill in the different rows:*/ if (!(array[i]=(int *)malloc(cols*sizeof(int))))} for (t=0;t<i;t++) /*Free all priory allocated memory:*/ free(array[t]); free(array); printf("Memory allocation failed, quiting… "); return; /*Terminate the program!*/ } for (j=0;j<cols;j++) /*Fill in the different columns:*/ array[i][j]=i*j; } for (i=0;i<rows;i++){ /*Print the different rows:*/ for (j=0;j<cols;j++) printf("%d ",array[i][j]); printf("\n"); }

המשך תרגיל 5 /*Free allocated memory:*/ for(i=0;i<rows;i++) free(array[i]); free(array); }

תרגיל 6 התכנית לא מדפיסה כלום. יש שגיאה בזמן ריצה .(run time error) התכנית תדפיס: 9 18 27 36 45 54 63 72. התכנית תדפיס אינסוף אפסים. התכנית תדפיס 0. התכנית תדפיס ערכים לא ידועים. אף לא אחת מהתשובות לעיל. עיין בקטע הבא וסמן את כל התשובות הנכונות: #include <stdio.h> #include <stdlib.h> #define MAX 10 void main(){ int *ptr, *arr[MAX]; int i, j; for (i=MAX-1 ; i>=0; i--) if (arr[i] = (int *) malloc(i * sizeof(int))) for (j=0; j<i; j++) *(*(arr+i)+j) = j*i; ptr = *(arr+MAX-1); while (*ptr) printf ("%d ", *ptr--); }

פתרון תרגיל 6

Bye!!!

Introduction to Programming in C