Introduction to Programming in C תרגול 7 1 1
נושאים מצביעים רקע אופרטורים על מצביעים מצביעים כפרמטרים לפונקציה הקצאת זיכרון דינאמית Malloc free
תאור הזיכרון של המחשב: מצביעים ניתן לחשוב על זיכרון המחשב כעל רצף של תאים, כל אחד בגודל בית )byte( כאשר כל בית בגודל של 8 סיביות )bits( כאשר כל סיבית יכולה לקבל או ערך 1 או ערך 0. סה"כ כל בית )byte( יכול לכן לקבל 256 ערכים שונים המייצגים את מנעד המספרים הבינאריים באורך 8. כתובת הזיכרון- כל תא בזיכרון מזוהה ע"י ערך מספרי המתאר את מיקומו המדוייק. ערך זה הינו הכתובת של התא בזיכרון address(.)memory למשל, אם נגדיר את המשתנים הבאים: char var1; // storage for type char is 1 byte on any platform. double var2; // storage for type double is mostly 8 bytes but can varies - it s platform dependent int var3; // storage for type int is mostly 4 bytes but can varies -it s platform dependent sizeof על מנת לדעת גודל טיפוס ניתן להשתמש בפונקציה sizeof המחזירה את גודל הטיפוס בבתים. בצורה : (name_of_character) sizeof אילו הינו כותבים לדוגמה : (char) sizeof היינו מקבלים. 1 תוכן הזיכרון- בכל כתובת בזיכרון מופיע ערך מספרי כלשהו המייצג את הערך הספציפי של הטיפוס הנמצא בכתובת זו. טווח ערכים זה נע בין 0 ל- 1-2^(8*sizeof(type)). משמעות הערך נגזרת מגודל מספר זה ומסוג הטיפוס עצמו השמור בכתובת זו.
אופרטורים מצביעים מצביעים :(pointers) מצביע הינו משתנה שהערך שלו הוא כתובת של משתנה כלשהו. במילים אחרות, מצביע הינו משתנה שמצביע למשתנה אחר. אם נרצה להגדיר את p כמצביע למשתנה כלשהו מטיפוס, int שורת ההצהרה תיראה כך: ;p* int באופן כללי, תבנית הצהרה על מצביעים הינה: <variable-type> *<variable name>; האופרטור & אם x הוא משתנה אזי x& היא כתובת הזיכרון של x, כלומר האופרטור & מציין "כתובתו של ". האופרטור האופרטור הינו אופרטור שפועל על מצביעים. למשל עבור הדוגמה הקודמת אם היינו כותבים בהמשך p=&x )כאשר x הוא משתנה מסוג p* )int היה שקול ל- x כלומר p* הוא התוכן של תא הזיכרון ש- p מצביע עליו. אופרטורי הקידום: +,- פעולות אריתמטיות של קידום ב- k מקדמת את הפוינטר ב k*sizeof(type) בתים.
תיאור הזיכרון במחשב var 1 var2 var3 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 כתובת של משתנה הינה הכתובת של הבית הראשון ברצף הבתים שמשתנה זה תופס בזיכרון. ברגע שנצהיר על משתנים כמצביעים, נוכל להציב לתוכם כתובות של משתנים. לדוגמא : 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 200 466675 p 466675 466676 466677 466678 466679 466680 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. הערה: לשם פשטות מתואר המצב בציור בו לטיפוס המצביע ולמשתנה int מוקצה לכאורה בית אחד בלבד אולם במציאות דרושים מספר בתים לייצג שני טיפוסים אלה.
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.*/ printf( %p, p) ;//print the address of p printf( %d, *p) ;//print 200 p=500; // < שקול= => x=500;. int *pi; זהירות בעת שימוש במצביעים: כשמצהירים על מצביע p אין הוא בהכרח מצביע על ערך חוקי! *pi = 100; /*wrong!!!! to correct : do before this operation : pi = <concrete address>; */ טעות זו ידועה בשם segmentation fault,זוהי אינה שגיאת קומפילציה, אלא, שגיאה בזמן ריצה. מצביעים למצביעים - כאמור מצביע הוא משתנה המכיל כתובת של משתנה. אותו משתנה מוצבע יכול עקרונית גם הוא להיות מצביע. לדוגמה נוכל להוסיף לקוד: int **p2=&p printf( %d,**p2);//print 200
העברת מצביעים כפרמטרים לפונקציה מכיוון שמצביעים הם משתנים לכל דבר, ניתן להעביר את ערכיהם בתור פרמטרים לפונקציות - מנגנון זה מאפשר לפונקציה נקראת לשנות את ערכיהם של משתנים בסביבה הקוראת )מאותה סיבה מצביעים יכולים להיות גם ערך החזרה של פונקציה(. לדוגמא,נכתוב פונקציה אשר מחליפה בין ערכיהם של זוג משתנים מטיפוס :int void swap(int a, int b){ int tmp = a; a = *b; *b = tmp; כתובת של מערך שמו של מערך דומה למצביע המייצג את הכתובת של האיבר הראשון בתוך המערך. על אף הדמיון הרב, קיים גם שוני בכך שמערך מייצג כתובת קבועה, שאינה ניתנת לשינוי במהלך התוכנית, בניגוד למצביע.
דוגמא נוספת #include <stdio.h> void main(){ int x, *px; int y, *py ; /*Define a variable of type int named "x" and a variable of type pointer to int named "px".*/ 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 int a, *b, c[4]; :C שאלה 1: נתונה השורה הבאה של תכנית בשפת סמנו את כל ההוראות שאינן יכולות להופיע באופן חוקי בהמשך התכנית. הוראה חוקית היא הוראה נכונה מבחינה תחבירית שעוברת קומפילציה. (א c[3]=8 *(c+3) = 8; //same as (ב *b); a = *(c + (ג 12; = *(c++) (ד b; c = c; b = (ה (ו (*c)++; a = (ז (*c)++; *(b+1) = *c; a = *b - (ח (ט *(b++); *c = (י *(&a); *(b++)= *b==2=a; (יא 2; == *b c[3] = (יב
תרגיל 1 נתונה השורה הבאה של תכנית בשפת C: int a, *b, c[4]; סמנו את כל ההוראות שאינן יכולות להופיע באופן חוקי בהמשך התכנית. הוראה חוקית היא הוראה נכונה מבחינה תחבירית שעוברת קומפילציה. (א c[3]=8 *(c+3) = 8; //same as (ב *b); a = *(c + (ג l-value*/ *(c++) = 12; /*Compilation Error: error C2105: '++' needs (ד l-value*/ c = b; /*Compilation Error: error C2106: '=' : left operand must be c; b = (ה (ו (*c)++; a = (ז (*c)++; *(b+1) = *c; a = *b - (ח (ט *(b++); *c = (י *(&a); *(b++)= l-value*/ *b==2=a; /*Compilation Error: error C2106: '=' : left operand must be (יא 2; == *b c[3] = (יב
עדכון מספר ערכים ראינו כבר כי ע"י שימוש בפונקציה ניתן לקבל ערך החזרה יחיד בלבד. לדוגמה: רוצים לחשב שני שורשים של משוואה ריבועית. דרך ראשונה לחשב זאת ע"י קריאות מתאימות לפונקציה : #include<stdio.h> #include<math.h> double roots(double a,double b,double,int discriminant_sign){ double discriminant = sqrt(b*b-4*a*c); discriminant *=discriminant_sign; return (b+discriminant)/(2*a); void main(){ double root1 = roots(2-6,4, 1); double root2 = roots(2,-6,4, -1); כאשר 1 מסמל חישוב שורש עם דיסקרימיננטה חיובית ו-)- 1 ( עם דיסקרימיננטה שלילית.
תרגיל 2 כתוב אותה פונקציה כך שהשורשים נשלחים כארגומנטים ומתעדכנים בפונקציה עצמה
פתרון ע"י שימוש במצביעים void roots(double a,double b,double c,double *pz1,double *pz2){ double discriminant = sqrt(b*b-4*a*c); *pz1=(-b+discriminant)/(2*a); *pz2=(-b-discriminant)/(2*a); void main(){ double z1,z2; roots(2,-6,4,&z1,&z2); printf( roots: %f %f\n,z1,z2); דרך זו עדיפה מכיוון שמבנה הפונקציה פשוט וטבעי יותר וגם הקריאה לפונקציה מתבצעת פעם אחת בלבד. במקרה זה אמנם עידכנו סה"כ 2 משתנים אבל יתכנו מקרים בהם נרצה לעדכן מספר רב יותר של משתנים ואז הדבר יהיה משמעותי יותר
תרגיל 3 כתוב פונקציה *st2) char * strstr(char *st1, char שמקבלת כארגומנט שתי מחרוזות. במידה שהמחרוזת st2 מוכללת במחרוזת,st1 הפונקציה מחזירה מצביע לתו של st1 שממנו מתחילה המחרוזת הזאת, אחרת הפוקציה מחזירה.NULL
תרגיל 3 #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;
המשך תרגיל 3 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() )קיצור ל- allocation.)memory פונקציה זו מקבלת כפרמטר את מס' הבתים שברצוננו להקצות ומחזירה את הכתובת של הבית הראשון ברצף הבתים שהקצאתה. אם הפונקציה נכשלת מוחזר הערך.NULL שחרור זיכרון דינאמית - מכיוון שהקצאת הזיכרון נעשתה בזמן ביצוע התוכנית, יש לדאוג לשחרר את הזיכרון לאחר שנסיים להשתמש בו. שחרור של זיכרון דינאמי נעשה ע"י קריאה לפונקציה.free() הפונקציה מקבלת מצביע לכתובת תחילת קטע הזיכרון שרוצים לשחרר. תוכנית שאינה משחררת זיכרון נחשבת לא תקינה ויכולה לגרום לבעיות ברמת הגורם המפעיל אותה.
אופרטורים free, שימוש בפונקציות: malloc #include <stdlib.h> //must add this library 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));.. free(p_list);
דוגמא להקצאת ושחרור זיכרון כאשר מקצים זיכרון הערך המוחזר על ידי פונקצית הקצאת זיכרון היא כתובת. יש מקרים שבעבורם הקצאת הזיכרון נכשלת והערך המוחזר על ידי הפונקציה הוא.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);
#include <stdio.h> #include <stdlib.h> int* foo (); int* foo (){ int arr[3]={1,2,3; return arr; void main(){ int* x=foo (); printf("%d",x[0]); נביט בתוכנית הבאה : דוגמא התנהגות תוכנית זו אינה מוגדרת מכיוון שהפונקציה מחזירה מצביע למערך לוקאלי. כאשר הפונקציה מסתיימת הזיכרון בו נמצא המערך אינו חוקי עוד לשימוש. נתקן את הפונקציה בצורה הבאה : int* foo (){ int *arr = (int*) malloc(sizeof(int)*3); arr[0]=1;arr[1]=2;arr2[3]; return arr; ובנוסף לאחר השימוש בפונקציה נדאג לשחרר זיכרון ע"י הוספת : free(arr); ל - main אחרי סיום השימוש במערך.
תרגיל 4 תוכנית להדגמה של מערך דו-מימדי דינאמי: כשרוצים להגדיר מערך דו מימדי בעל גודל משתנה, עלינו ליצור מערך של מצביעים למערכים. גודל המערך לא ידוע בתחילת התכנית ולכן נגדיר את המערך באמצעות פונקצית.malloc() בתחילה נאתחל מערך של מצביעים, ולאחר מכן נאתחל כל מצביע להיות מערך של ה- type הרצוי. למשל, יצירת מערך של int -ים בגודל המוגדר ע"י המשתמש שבכל איבר בו יש את הערך של מכפלת האינדקסים שלו:
תרגיל 4 #include <stdio.h> #include <stdlib.h> void main(){ int i,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;...
המשך תרגיל 4 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");
המשך תרגיל 4 /*Free allocated memory:*/ for(i=0;i<rows;i++) free(array[i]); free(array);
תרגיל 5 צריך לממש פונקציה n) void transpose(int** arr, int arr מערך דינאמי דו-מימדי בגודל n. X n )מייצג מטריצה ריבועית( n גודל המימד הריבועי של המטריצה. הפונקציה תשנה את המערך הדו-מימדי ע"י ביצוע פעולת transpose עליו. אם לפני הקריאה לפונקציה arr[i][j] = x ו y,arr[j][i] = אזי אחרי סיום ריצת הפונקציה arr[i][j] = y ו x.arr[j][i] = שימו לב השינוי הוא.in-place
- תרגיל 5 פתרון void tranpose (int** arr, int n) { int i, j, tmp; for (i=0; i < n; i++) for (j=i+1; j < n; j++) { tmp = arr[i][j]; arr[i][j] = arr[j][i]; arr[j][i] = tmp;
תרגיל 5 ב ' צריך לממש פונקציה n) int** transpose2(int** arr, int arr מערך דינאמי דו-מימדי בגודל n. X n )מייצג מטריצה ריבועית( n גודל המימד הריבועי של המטריצה. הפונקציה תייצר מערך דו-מימדי חדש, שערכי אבריו יהיו אברי המערך הדו-מימדי המקורי לאחר ביצוע פעולת.transpose
תרגיל 5 פתרון ב' - int** tranpose2 (int** arr, int n) { int i, j, tmp_arr; if (! tmp_arr = malloc(sizeof(int*) * n)) return NULL; for (i = 0; i < n; i++) { if (! tmp_arr[i] = malloc(sizeof(int) * n)) { for (j = 0; j < i; j++) free(tmp_arr[j]); free(tmp_arr); return NULL; for (j = 0; j < n; j++) tmp_arr[i][j] = arr[i][j]; transpose(tmp_arr, n); return tmp_arr; היינו יכולים בשלב הזה לבצע את ה- Transpose בעצמנו, אבל העקרון המודולרי היה עובד גם עבור פעולות מסובכות יותר, כאלה שלא בהכרח היינו יודעים/רוצים לממש בעצמנו.
תרגיל 6 עיין בקטע הבא וסמן את כל התשובות הנכונות: #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--) התכנית לא מדפיסה כלום. יש שגיאה בזמן ריצה error).(run time התכנית תדפיס:.72 63 54 45 36 27 18 9 התכנית תדפיס אינסוף אפסים. התכנית תדפיס 0. התכנית תדפיס ערכים לא ידועים. אף לא אחת מהתשובות לעיל. if (arr[i] = (int *) malloc(i * sizeof(int))) for (j=0; j<i; j++) *(*(arr+i)+j) = j*i;//same as arr[i][j]=j*i ptr = *(arr+max-1); while (*ptr) printf ("%d ", *ptr--);.1.2.3.4.5.6.7
6 פתרון תרגיל
נתונה הפונקציה הבאה: char *search(char *str1,char *str2){ int i, j, k, length; char *temp, *aux=null; for(i=length=0;*(str1+i);i++) for(j=0;*(str2+j);j++){ for(k=0;*(str1+i+k)&& *(str1+i+k)==*(str2+j+k);k++); if(k>length){ length=k; aux=str1+i; if(aux) if(temp=(char *)malloc(length+1)){ for(i=0;i<length;i++) *(temp+i)=*(aux+i); *(temp+i)='\0'; return temp; return NULL;.
הסבר בקצרה מה יעודה של הפונקציה הנ"ל. מה הפלט של קטע קוד הבא: char sentence1[]= It is clever of him to solve the problem, char sentence2[]= I am glad to solve your problem, *sentence3; sentence3 = search(sentence1, sentence2); puts(sentence3);
תשובות א. מחזירה מצביע להעתק של מחרוזת הארוכה המשותפת לשתי המחרוזות. ב. solve to