1. מבוא כללי למדעי המחשב תרגול 6

2. מה הכתובת של “הבית האדום?”
הבית הצהוב
הבית האדום
שמעון
רמי
כתובת : רחוב קוקוריקו 1
כתובת : רחוב קוקוריקו 2
הבית הורוד
הבית הירוק
אבנר
יוסי
כתובת : רחוב קוקוריקו 3
כתובת : רחוב קוקוריקו 4 2
מה הכתובת של “הבית האדום?”
רמי
מי גר בבית מספר 2?
רמי
מי גר ב“בית האדום?”

3. 2000 b a 5 3 כתובת : 1000 כתובת : 2000 c d 7 80 כתובת : 3000
כתובת : 4000
2000
מה הכתובת של?a 5
מה נמצא בתא 2000? 5
מה נמצא ב a?

4. מצביעים לכל משתנה שמוגדר בתוכנית יש כתובת הכתובת שלו היא מיקומו בזכרון
למשל
כאשר משכנים מספר מסוג int אזי צורכים 4 bytes.
int a; a
5000

5. מצביעים a
5000 5
int a;
int b;
a = 5;
b = 7; b
5004 7

6. מצביעים int a, b; int *p1; int *p2; a = 5; b = 7; p1 = &a; p2 = &b; a
5000 5
int a, b;
int *p1;
int *p2;
a = 5;
b = 7;
p1 = &a;
p2 = &b; b
5004 7 p1
7026
5000 p2
7030
5004

7. מצביעים *p1 = 2; *p2 = *p1; int a, b; int *p1; int *p2; a = 5; b = 7;
5000 5
int a, b;
int *p1;
int *p2;
a = 5;
b = 7;
p1 = &a;
p2 = &b;
5004 7 b p1
7026
5000
5004 p2
7030
*p1 = 2;
*p2 = *p1;

8. מצביעים *p1 = 2; *p2 = *p1; int a, b; int *p1; int *p2; a = 5; b = 7;
5000 2
int a, b;
int *p1;
int *p2;
a = 5;
b = 7;
p1 = &a;
p2 = &b;
5004 2 b p1
7026
5000
5004 p2
7030
*p1 = 2;
*p2 = *p1;

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

10. #include <stdio.h>
int main() {
int a=10,b=2;
int *p1,*p2;
p1 = &a;
p2 = &b;
printf(“%p %p \n”,p1,p2);
printf(“%d %d \n”,*p1,*p2);
return 0; }

11. מצביעים עד היום הפונקציות שלנו ידעו לקבל ערכים של
משתנים ולהשתמש בהם. הן לא ידעו לקבל משתנים
ולשנות את הערכים שלהם (מלבד פונקציה אחת!)
הפונקציות שלנו ימשיכו לקבל ערכים בלבד, רק שכעת
אנו יכולים להעביר להם בתור ערך כתובת של משתנה !

12. אין צורך לדעת את כתובותיהם שלa ואת b, אלא רק את ערכיהם
int a=3,b=5;
printf(“%d %d”,a,b)
printf a 3 3
2020 b 5 5
2034
אין צורך לדעת את כתובותיהם שלa ואת b, אלא רק את ערכיהם

13. צריך לדעת את כתובותיהם שלa ו b, ולא את ערכיהם
int a,b;
scanf(“%d %d”,&a,&b)
scanf a
2020 3 5 b
2034
צריך לדעת את כתובותיהם שלa ו b, ולא את ערכיהם

14. int main() {
int a;
scanf(“%d”,&a); } a
5000
scanf
*pa = ערך מהמשתמש

15. int main() {
int a=10,b=2,x=3,y=5; …
swap(x, y);
swap(a, b); }
void swap (int q,int p) {
int temp =p;
p = q;
q = temp; }

16. void swap (int *p,int *q) { int temp = *p; *p = *q; *q = temp; }
int main() {
int a=10,b=2,x=3,y=5; …
swap(&x,&y);
swap(&a,&b); } 5 x
5000 3 y
5004 3 5
void swap (int *p,int *q) {
int temp = *p;
*p = *q;
*q = temp; } p
7026
5000
7030
5004 q
7034 3
temp

17. void rectangle(int a,int b,int *area,int *circuit);
תרגיל
כתבו פונקציה שמקבלת אורך ורוחב של מלבן
ומחזירה את שטח המלבן ואת היקפו.
void rectangle(int a,int b,int *area,int *circuit);
int main() {
int x, y;
int area,circuit;
scanf("%d %d",&x,&y);
rectangle(x,y, &area,&circuit);
printf(“Area is %d Circuit is %d\n",area,circuit);
return 0; }

18. פתרון void rectangle(int a,int b,int *area,int *circuit) {
*area = a * b;
*circuit = 2 * (a + b); }

19. הקשר בין מערכים למצביעים
נרצה לעמוד על הקשר בין מערך למצביע
מאחר ומערכים הם הכללה של משתנים הרי שברור
שלמערך ולכל אחד מאיבריו יש כתובת
a[0]
5000
כדי להגיע לכתובת של תא
במערך פשוט נכתוב &a[2]
אם נרצה את הכתובת של
המערך עצמו אזי זה שם
המערך
a[1]
5004
a[2] 5
5008 
a[9]

20. הקשר בין מערכים לפונקציות
כיצד נכתוב פונקציה אשר תקבל כפרמטר מערך ?
הפונקציה תקבל מערך (את כתובתו) ותדפיס אותו:
void PrintArray(int a[],int size) {
int i;
for (i=0;i<size;i++)
printf(“%d”,a[i]); }

21. הקשר בין מערכים לפונקציות
הפונקציה תקלוט איברים לתוך מערך
void GetArray(int a[],int size) {
int i;
for (i=0;i<size;i++)
scanf(“%d”,&a[i]); }

22. void GetArray(int a[],int size);
void PrintArray(int a[],int size);
int main() {
int a[SIZE];
GetArray(a,SIZE);
PrintArray(a,SIZE);
return 0; }

23. תרגיל 2 כתבו את הפונקציות הבאות: פונקציה שממלא מערך במספרים אקראיים
פונקציה שמדפיסה מערך
פונקציה שהופכת את המערך (רמז: השתמשו בפונקציה swap )

24. פתרון מילוי מערך void fill_array(int array[], int size) { int i;
srand(time(NULL));
for (i = 0; i < size; i++)
array[i] = rand(); }

25. פתרון הדפסת מערך void print_array(int array[], int size) { int i;
for (i = 0; i < size; i++)
printf("%d ", array[i]);
printf("\n"); }

26. פתרון הפיכת מערך void reverse_array(int array[], int size) { int i;
for (i = 0; i < size/2; i++)
swap(&array[i], &array[size i]); }

27. #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define SIZE 5
void fill_array(int array[], int size);
void reverse_array(int array[], int size);
void print_array(int array[], int size);
void swap(int *a, int *b);
int main() {
int my_arr[SIZE];
fill_array(my_arr, SIZE);
print_array(my_arr, SIZE);
reverse_array(my_arr, SIZE);
return 0; }

28.  חשבון מצביעים כדי להגיע לתא השלישי במערך נוכל לעשות a[2] או *(a+2)
כדי להגיע לתא השלישי
במערך נוכל לעשות a[2] או
*(a+2)
a[0]
5000
a[1]
5004
a[2] 5
5008 
a[9]

29. חשבון מצביעים reverse_array(my_arr, my_arr + SIZE -1);
void reverse_array(int *begin, int *end) {
while (begin < end)
swap(begin, end);
begin++;
end--; } a e d r a e
begin
end

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

31. a b
קלט 1 3
100 11 22 22
445
445 35 35 15 22
445 35
&a[4]
פלט

32. int. findSubArray (int. array, int array_size, int
int *findSubArray (int *array, int array_size, int *sub_array, int sub_size) {
int i, j;
for (i = 0; i <= array_size - sub_size; i++,array++)
for (j = 0; j < sub_size; ++j)
if ( *(array + j) != sub_array[j] )
break;
if (j == sub_size)
return array; }
return NULL;

33. #include <stdio.h>
int *findSubArray (int *array, int array_size, int *sub_array, int sub_size);
int main() {
int array1[] = {1, 45, 67, 1001, -19, 67, 89, 1004, -867, 34, 3, -1900, 10029},
array2[] = {34, 3, -1900}, *position;
position = findSubArray (array1, sizeof (array1) / sizeof (int),
array2, sizeof (array2) / sizeof(int));
printf ("array2 appears in array1 starting from place : %d.\n",
(position == NULL)? -1 : position - array1 + 1);
return 0; }

34. מחרוזות מחרוזת – מחרוזת זה מערך של תווים אשר מסתיים ב ‘\0’.
‘S’
a[0]
5000
char a[6] = “Shai”;
printf(“%s”,a);
a[1]
‘h’
5001
a[2]
‘a’
5002
5003
a[3]
‘i’
a[4]
‘\0’
5004
a[5]
5005
הדפסה באמצעות %s

35. מחרוזות הסיום ב ‘\0’ מאפשר לנו להעביר מחרוזות
לפונקציות מבלי לציין את גודלם!!!
פונקציה טיפוסית של מחרוזות תראה כך:
void string_func(const char *s) { …
while (*s != ’\0’)
מונע שינוי של המחרוזת

36. #include <stdio.h> int strlen (const char * str) {
const char *eos = str;
while( *eos++ ) ;
return( eos - str - 1 ); }
int main()
char str[]="Shai";
printf("%d",strlen(str));
return 0;
מה קורה פה ?
100
101
102
103
104
105
106 L I N U X
‘\0’
eos
str

37. דרכים נוספות להגדיר מחרוזות
char *p = “hello”; char s[ ] = “hello”; p s h e l l o \0 h e l l o \0
קלט למחרוזת
scanf(“%s”, str);
עד לרווח

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

39. #include <stdio.h>
int compare (char s1[ ],char s2[ ]) {
int k;
for ( k=0; s1[k] != ‘\0’ || s2[k] != ‘\0’; k++ )
if ( s1[k] != s2[k] )
return 0;
return 1; }
void main()
char s1[31],s2[31];
scanf(“%s%s”,s1,s2);
printf(“%d\n”,compare(s1,s2));

40. string.h הספריה מכילה בין השאר את הפונקציות הבאות לטיפול במחרוזות:
strlen(s) – מחזירה את האורך של המחרוזת s.
strcpy(s,t) – מעתיקה את המחרוזת t ל-s.
strcmp(s,t) – משווה ביו המחרוזות s ו-t.
strstr(s,t) – מחפשת את המחרוזת t בתוך המחרוזת s.

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

42. #include <stdio.h>
#include <string.h>
int main() {
char s[101];
int k,len;
scanf(“%s”,s);
len = strlen(s);
for ( k=0; k<len/2; k++ )
if ( s[k] != s[len-1-k] )
printf(“The string is not a palindrome!\n”);
return 0; }
printf(“The string is a palindrome!\n”);

43. התוכנית כבר כתובה ולא ניתן לשנות את גודל המערך!
הקצאת זיכרון דינאמית
הזיכרון המקסימאלי ששימש את התוכנית שלנו עד היום היה קבוע מראש.
לפני הרצת התוכנית, לאחר שהתוכנית עברה את שלב
התרגום, כל המערכים שבתוכנית גודלם נקבע ואינו ניתן לשינוי
במהלך ריצת התוכנית!
בעיות אפשריות:
אם הגדרנו מערך בגודל 100 לשמור את ציוני כל הסטודנטים
וכעת מגיע סטודנט נוסף מה נעשה?
התוכנית כבר כתובה ולא ניתן לשנות את גודל המערך!

44. הקצאת זיכרון דינאמית
C מאפשרת לנו להקצות זיכרון תוך כדי ריצת התוכנית וכך
להגדיר מערכים ומבנים אחרים בצורה דינאמית
int main() {
int a[10];
a[6] = 7; }
10 ints
6024
int main() {
int *a;
a = (int*) malloc(sizeof(int) * 10);
a[6] = 7; } a
6024
10 ints

45. שחרור זיכרון שהוקצה דינאמית
כל שטח זיכרון שהוקצה ע"י המתכנת צריך להיות משוחרר בסיום השימוש בו. לכן חייבים תמיד להחזיק את כתובת האזור שהוקצה על מנת שנוכל לשחרר אותו בסיום השימוש.
int main() {
int *a;
a = (int*) malloc(sizeof(int) * 10);
a[6] = 7;
free(a); }
6024 a
6024

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

47. הקצאת זיכרון דינאמית #define SIZE 10 int main() { int *a,*b,i;
a = (int*) malloc(sizeof(int) * SIZE);
for (i=0;i<SIZE;i++)
a[i] = i;
b = (int*) malloc(sizeof(int) *( SIZE + 1))
b[i] = a[i];
b[i] = i;
free(a);
free(b); }

48. הפונקציות נמצאות ב- stdlib.h void *malloc(size_t size);
Allocate size bytes. Successful call return base address; otherwise NULL is returned.
void free(void *ptr)
Deallocate the memory pointed by ptr which must be a base address of previously allocated memory

49. דוגמא – הקצאת זיכרון דינאמית
void FillArray(int arr[ ], int n) {
int i;
for(i = 0; i < n; i++)
arr[i] = rand()% ; }
void PrintArray(int arr[ ], int n)
for(i = 1; i <= n; i++)
printf("%3d ", arr[i - 1]);
if (i % 10 == 0)
printf("\n");
#include <stdio.h>
#include <stdlib.h>
void FillArray(int arr[ ], int n);
void PrintArray(int arr[ ], int n);
int main() {
int *a, n;
scanf("%d", &n);
a = (int *)malloc(n * sizeof(int));
FillArray(a, n);
PrintArray(a, n);
free(a);
return 0; }