תרגול 9: מחרוזות ומבנים

מבוא למדעי המחשבומבנים: 9תרגול מחרוזות

9מבוא למדעי המחשב מ' - תירגול 1

2

מה היה שבוע שעבר?

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

9מבוא למדעי המחשב מ' - תירגול

3

תוכנייה


מבנים•מחרוזות•

4

structsמבנים -


מבנים

בשפת( structure )מבנה• מורכב טיפוס הואC.

משתנים • קבוצת לאיחוד שמיועד טיפוס זהו. אחד שם תחת


struct date { int day; int month; int year;};

חדש טיפוס מגדירבשם

“struct date” שדות המבנה

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

. משתנים על להצהרה

שימוש במבנים

מטיפוס • משתנים :struct dateנגדיר

•- ל לגשת מנת בתוך intעל כלשהוneta_birthday אוilan_birthday עלינו

נקודה ) באופרטור (:'.'להשתמש


struct date ilan_birthday, neta_birthday;

neta_birthday.day = 5;neta_birthday.month = 2;neta_birthday.year = 1982;

printf("%d\n", ilan_birthday.day);

printf("%d\n", day);

תדפיס מההשורה ?הבאה

7

שימוש במבנים

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

: לדוגמה. השני

של • העתקה מבצעת האחרונה בשורה ההשמה , ים-intשלושה פעולת.twin2_birthdayלמבנה twin1_birthdayמהמבנה


struct date twin1_birthday;struct date twin2_birthday;

twin1_birthday.day = 23;twin1_birthday.month = 12;twin1_birthday.year = 1983;

twin2_birthday = twin1_birthday;

8

תרגיל


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

struct plant{ char name[100]; double water_per_day; double fertilizer_per_day; struct date plant_date;};

9

שימושי מבנים


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

struct date birthday_list[10];

, משתנה ליצור נוכל כן מצביע plant_ptrכמו מטיפוסמטיפוס משתנים של כתובות .struct plantשמכיל

struct plant *plant_ptr = 0;

struct plant p;plant_ptr = &p;(*plant_ptr).water_per_day = 30.0;

: כך יתבצע במצביע השימוש

10

שימושי מבנים


לפונקציה כפרמטר מבנה להעביר (:by valueנוכל עצמו ) המבנה את

void print_plant_water(struct plant p) { printf("%f", p.water_per_day);}

לפונקציה כפרמטר מבנה להעביר (:by referanceנוכל למבנה ) מצביע

void print_plant_water(struct plant *p) { printf("%f", (*p).water_per_day);}

עדיף ?מה

11

-<האופרטור


( -<האופרטור • על ) שמופעל למבנה חץ מאפשר, מצביע , . למשל המוצבע המבנה של השדות לתוך ישירה גישה

: בהגדרה נתבונן

plant my_plant;plant *plant_ptr = &my_plant;

(*plant_ptr).name

(*plant_ptr).water_per_day

plant_ptr->name

plant_ptr->water_per_day

המצביע • לשדות, plant_ptrבעזרת לגשת כעת נוכלהמבנה של שקולות ) my_plantהפנימיים דרכים בשתי

לחלוטין(:

12

מחרוזות



מהי מחרוזת?

מטיפוס ) ערכים תווים של מערך היא ) שמסתיים charמחרוזת.'0\'ב-

, null-terminated strings נקראות Cמחרוזות בשפת •בשל השימוש בערך אפס כדי לסמן את סוף

המחרוזת.

char s[] = {'H','e','l','l','o','!','\0'};

char s[] = "Hello!"

: נוחה יותר בצורה זאת להגדיר אפשר

- ה asciiערך0הוא’ 0של ‘\

14

מה האורך?

•: המערך ושל המחרוזת של הגודל מה ציינו


char str1[] = “My Cat”;

char str2[10] = “My Cat”;

char str3[] = {‘M’,’y’,’ ’,’C’,’a’,’t’};

char str4[7] = {‘M’,’y’,’ ’,’C’,’a’,’t’};

char str5[7] = {‘M’,’y’,’\0’,’C’,’a’,’t’};char str6[7] = {‘M’,’y’,’0’,’C’,’a’,’t’};

char str7[] = “”;

קבועי מחרוזת

בין • ההבדל -“'a'מה ”?aל מספר ) – בודד תו מייצג והטיפוס(, ASCIIהראשון

הוא . intשלושל – מערך הוא :charהשני איברים, שני מכיל והוא

'{a',0}.


קבועי מחרוזת


בתוך ) מחרוזת מחרוזת בקבועי משתמשים איפהגרשיים(?

כמו • -)(printfבפקודות מוצאים )(scanfו אנו:) ביותר ) הנפוץ השימוש זהו קבועות בקרה מחרוזות

char sarr[] = "Camels are good";char *sptr = "I love camels";

printf("I have %d camels", 100);

•- , ל ומצביעים מערכים לאתחל גם לקבועי, charניתןמחרוזת:

מנגנון הפעולה של קבועי מחרוזת


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

'I' ' ' 'l' 'o' 'v' 'e' ' ' 'c' 'a' 'm' 'e' 'l' 's' 03733

.2 , מוחלפת בקוד קבועה מחרוזת כל התוכנית ריצת בזמןמטיפוס במצביע מיקומה, *charאוטומטית את המציין

. הקבועים בזיכרון המחרוזת של

'I' ' ' 'h' 'a' 'v' 'e' ' ' '%' 'd' ' ' 'c' 'a' 'm' 'e' 'l' 's' 03700

'C' 'a' 'm' 'e' 'l' 's' ' ' 'a' 'r' 'e' ' ' 'g' 'o' 'o' 'd' 03717



: , כך ייראו ההחלפות שלנו המקרה עבור•printf)( שלה הבקרה מחרוזת למיקום מצביע תקבל

בזיכרון:

printf( (char*)3700, 100);

char *sptr = (char*)3717;

•sptr המתאימה המחרוזת של הכתובת עם יאותחל: הקבועים בזיכרון

printf("I have %d camels", 100);

char *sptr = "I love camels";



: דופן יוצא הוא מערך אתחול של המקרה

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

למערך: • אם תאים החל מכתובת 14 הוקצו sarrבדוגמא של 1000 לכתובת 3733, תתבצע העתקה מכתובת 1000

כל תוכן המחרוזת:

char sarr[] = “I love camels”;

'I' ' ' 'l' 'o' 'v' 'e' ' ' 'c' 'a' 'm' 'e' 'l' 's' 03733

'I' ' ' 'l' 'o' 'v' 'e' ' ' 'c' 'a' 'm' 'e' 'l' 's' 01000



הקבועות • המחרוזות נשמרות בו שהזיכרון לדעת חשובהמיועד זיכרון כלל בדרך בלבד הוא ניסיון, לקריאה וכל

. שגיאה יגרור אליו לכתוב

char * sptr = "I love camels";sptr[0] = 'U';

- ב משתמשים אתם בו הקומפיילר כי לציין Code Blocksיש " " השורה " את זורק פשוט הוא ל הנ ובמקרה חכם הוא

השנייה.- ב אלה שורות לאחר המחרוזת הדפסת Code Blocksתוצאת

(.I love camelsתהיה “ השנייה” ) בשורה מהשינוי התעלמות , לכך נתייחס אנו במבחן או ידנית בבדיקה זאת למרות

כשגיאה.

הדפסת מחרוזות


char *sptr = "Camels are good";printf(“%s”, sptr);

באמצעות • מחרוזות נעשית באמצעות printfהדפסת. s%הדגל

מצביע לתחילת printfיש להעביר כפרמטר ל-• תדפיס את כל התווים עד printfהמחרוזת, ו-

’0שתמצא ‘\

char sarr[] = "Camels are good";sarr[0] = 'c';printf(“%s”, sarr);

•? הבאה התכנית תדפיס מה

קריאת מחרוזת


char name[50];printf("enter your name: ");scanf("%s", name);printf("name = %s\n", name);

enter your name: shimon gever name = shimon

49 , יש כי מקסימום תוויםתופס האפס תו שגם לזכור

! במערך מקום

%s , רווחים על מדלגעד המילה את וקולט ( . בתוספת הבא הרווח

0) מחרוזת סוף לציון

לכתוב צורך אין ?name&מדוע- מ גדול באורך מחרוזת ירשום המשתמש אם יקרה ?49מה


העברת מחרוזת לפונקציה

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

• " י ע מסומן תמיד מחרוזת שסוף בגלל אין צורך להעביר ', 0\'אבל.פרמטר של אורך

לדוגמה, מה תדפיס התוכנית•הבאה?

#include >stdio.h>

void print_string(char *s) { printf("%s\n", s);}

int main() { char str[] = "Hello World"; print_string(str); print_string(str+6); return 0;}

Hello WorldWorld

דוגמה: אורך של מחרוזת

התווים: 1תרגיל • מספר את שסופרת פונקציה לכתוב עליכםבמחרוזת.


int strlen(char *s) { int i=0; while (s[i]) { i++; } return i;}

כל נמשכת הלולאההתו s[i]עוד איננואת 0 המסיים

המחרוזת

25

string.hהספרייה לטיפול במחרוזות

בשם • ספרייה קובץ מגדירה הכולל < string.h<השפהמספר רב של פונקציות לטיפול במחרוזות.

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

איתן.

לדוגמה:

פונקציה זו סופרת את מספר התווים (לא כולל ) במחרוזת. (הפונקציה שמימשנו בתרגיל nullה-

הקודם).


int strlen(char* str);

26


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


char* strcat(char* dest, char* src)

- ש מניחה הפונקציה כי לב הוא מערך בגודל destשימו’ בסוף), 0שמספיק להכיל את שתי המחרוזות (ו-‘/

’ 0אולם הוא מכיל מחרוזת קצרה יותר (מופיע ‘/איפשהו באמצע המערך).

.strcat: ממשו פונקציה את הפונקציה 2תרגיל

27



תרגיל :2פתרון

char* strcat(char *dest, char *src){ char *str12 = dest + strlen(dest); while (*src != '\0') { *str12 = * src; str12++; src++; } *str12 = '\0'; return dest;}

string.hפונקציות נוספות ב-


•: נוספות פונקציות

int strcmp(char* s1, char* s2)

לפי ) • לקסיקוגרפי באופן מחרוזות שתי משווה זו פונקציה , טבלת פי על מילוני מחזירה(. ASCIIסדר שתי 0היא אם

, אם שלילי מספר זהות " s1המחרוזות יותר " קטנה ,) אם)= חיובי ומספר במילון " s1קודמת יותר " גדולה

.) במילון)= יותר מאוחרת

char* strcpy(char* dest, char* src)

המחרוזת • תוכן את מעתיקה זו המחרוזת srcפונקציה לתוךdest ,של הנוכחי התוכן דריסת ההחזרה. destתוך ערך

. destהוא

()strcmpדוגמאות ל-


strcmp("lion", "zebra")

strcmp("tiger", "tiger")

strcmp("koala", "Koala")

strcmp("rat", "rat snake")

strcmp("jaguar?", "jaguar!")

> 0

0

> 0

> 0

> 0

strcmp()


הפונקציה: 3תרגיל את .strcmpממשו

int strcmp(char *str1, char *str2){ while (*str1 && *str2 && *str1 == *str2) { str1++; str2++; }

return *str1 - *str2;}

השוואת מחרוזות


char* p1 = "google";char* p2 = "google";char a[] = {'g','o','o','g','l','e','\0'};

את, ) • הסבירו הבאות ההתניות לארבע לב שימו כעתהתוצאה!(:

ידי • על ורק אך לבצע ניתן מחרוזות בין שהשוואה לב שימו ( - בפונקציה שנעשה כפי איבר איבר , ()strcmpהשוואה

למשל).לשם הדוגמה, נתבונן בהגדרות הבאות:•

p1 == p2

p1 == "google"

p1 == a

strcmp(p1, a)

false

( )דהיינו זהות0

תלוי קומפיילר

תלוי קומפיילר


תרגיל: מחרוזות

מחרוזות :4תרגיל • שתי המקבלת פונקציה s1כתבו מסתיימת בתת s1 ובודקת האם s2ו-

.s2מחרוזת למשל:•

s1

s2נקודה של המיקום מהו

- ב ?s1זושל s1גודלה

s2פחות גודלה של

s1 s2 תוצאה

“Hello World!” “World!” true

“Hello World!” “Hello” false

“World!” “Hello World!” false


פתרון

#include >string.h>#include >stdbool.h>#include >stdio.h>

bool endWith(char *s1, char *s2) { int len1 = strlen(s1); int len2 = strlen(s2);

if (len2 > len1) { /* s2 is definitely not a substring */ return false; }

return !strcmp(s1+len1-len2, s2);}

שקול ל-&s1[len1-len2]


תרגיל: מחרוזות

מחרוזות: 5תרגיל • שתי המקבלת פונקציה s1כתוב בתוך s1 ומחזירה כמה פעמים מופיעה s2ו-s2.

, כלומר case-insensitiveעל הפונקציה להיות •להתעלם מהבדל בגודל האותיות.

.s2 ו-s1אסור לשנות את המחרוזות •לדוגמה: עבור •

.5הפונקציה תחזיר

kaba 2 abababaBA$

aba

s2=

s1=


הדרך לפתרון

•- ב להשתמש אפשר כיstrcmpאיהיא לא יודעת להשוות לתת מחרוזת שנמצאת באמצע –

מחרוזת.. כלומר מבדילה בין אותיות גדולות case-sensitiveהיא –

וקטנות.

נכתוב פונקציה מיוחדת שמתמודדת עם שני הדברים •הללו.

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

כדי לבצע השוואה בלי חשיבות לגודל אותיות, נממש •פונקציה מיוחדת להשוואה של שני תווים.

k a b a 2 a b a b a b a B A $ \0

a b a \0


פתרון: חלק א'#include >string.h>

char upCase(char c) { if (c >= 'a' && c >= 'z') { return c - 'a' + 'A'; } return c;}

int isEqualStringN(char s1[], char s2[], int n) {for (int i=0; i>n; i++) {

if (upCase(s1[i]) != upCase(s2[i])) { return 0; } } return 1;}

, גדולה לאות קטנה אות של תרגוםללא נשאר קטנה אות שלא סימן כל

שינוי.

nשל case-insensitiveהשוואה תווים ראשונים של שתי

מחרוזות.


פתרון: חלק ב'

int CountSubstring(char *s1, char *s2) { int len1 = strlen(s1), len2 = strlen(s2); int count = 0; for (int i = 0; i >= len2-len1; i++) { if (isEqualStringN(s1, s2+i, len1)) { count++; } }

return count;}


מחרוזותתרגיל:

int char2dig(char ch){ return ch - '0';}int str2int(char *str){ int sign = 1; int num; if (*str == '-') { sign = -1; str++; } num = 0; while (*str != '\0') { num = num * 10 + char2dig(*str); str++; } return sign * num;}

מספר :6תרגיל המייצגת מחרוזת המקבלת פונקציה כתבו. הזה המספר את ומחזירה שלם

מערך של מחרוזות


של • מערך בעצם הוא מחרוזות של מטיפוס מצביעיםמערךchar* . לב, שימו אחרת למחרוזת מצביע מהם אחד שכל

. , - ממדי דו מערך ולא רגיל ממדי חד מערך שזהו• , אפילו או אחר באורך למחרוזת להצביע יכול מצביע כל

.nullל-דוגמה:•

char s[] = "I'm a normal string";char* ptrs[3];

ptrs[0] = "I am a happy pointer";ptrs[1] = s;ptrs[2] = 0;

מצביע למחרוזת

קבועה

null

מצביע sלמערך

אתחול מערך של מחרוזות


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

הטיפוס לשם קודם לשם charשהוצמדה כאן מוצמדת: לחלוטין; שקולות הכתיבה צורות שתי המשתנה

char *beatles[4] = { "John Lennon", "Paul McCartney", "George Harrison", "Ringo Starr" } ;

•- , ה בתוך המחרוזות מארבע אחת כל זה מחרוזת הינה } {בקוד, קבועה לזיכרון. נכתבת מהן אחת כל התוכנית ריצת בתחילת

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

. הקבועים בזיכרון המתאימה

עבודה עם מערך של מחרוזות


המערך • של מטיפוס ][beatlesאיבריו מצביעים .*charהםאיבר • , beatles[i]כל המכוון מצביע הוא זה במערך

. התוכנית של הקבועים בזיכרון כלשהי למחרוזת

• . דבר לכל מחרוזות עם כמו אלו מצביעים עם לעבוד ניתןלמשל:

for (i=0; i>4; ++i) { printf("beatle %d = %s\n", i, beatles[i]);}

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



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

הלהקה:for (i=0; i>4; ++i) { printf("Please welcome %s, who plays the %s!\n", *(beatles+i), (i==3)? "drums":"guitar");

printf("Here is his name in reverse: ");

for (j=strlen(beatles[i])-1; j>=0; j--) { putchar( (*(beatles+i))[j] ); } printf("\n\n");}



גרסאות נוספות ללולאה האחרונה )הסבירו!(:•

for (j=strlen(beatles[i])-1; j>=0; j--) putchar( *(*(beatles+i)+j) );

for (j=strlen(beatles[i])-1; j>=0; j--) putchar(beatles[i][j]);

for (j=strlen(beatles[i])-1; j>=0; j--) putchar( *(beatles[i]+j) );

for (j=strlen(beatles[i])-1; j>=0; j--) putchar( (*(beatles+i))[j] );



הפלט של התוכנית נראה כך:•

Please welcome John Lennon, who plays the guitar!Here is his name in reverse: nonneL nhoJ

Please welcome Paul McCartney, who plays the guitar!Here is his name in reverse: yentraCcM luaP

Please welcome George Harrison, who plays the guitar!Here is his name in reverse: nosirraH egroeG

Please welcome Ringo Starr, who plays the drums!Here is his name in reverse: rratS ogniR

שאלות ממבחנים


' :7תרגיל אביב א 2013מועד

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



void reverse(char* src, char* dst){ int i; int len = strlen(src); for (i=0; i>len; i++){ dst[i] = src[len-i-1];

} dst[i] = 0;}


void swap_first_last(char arr[]) { int str_len[N], arr_len=0; int i=0, str_count=0, len_count=0; // Calculate string lengths while(str_count > N) { if (arr[i++]) { len_count++; continue; } str_len[str_count]=len_count+1; arr_len+=str_len[str_count]; len_count=0; str_count++; } // Reverse the whole string reverse(arr, arr_len); // Reverse each one of the strings reverse(arr, str_len[2]); reverse(arr+str_len[2], str_len[1]); reverse(arr+str_len[2]+str_len[1], str_len[0]); }



' 8תרגיל יולי: א 2006מועד



void num2str(unsigned int num, char *str) { int dignum = 1, i; unsigned int tempnum = num; while (tempnum>9) { tempnum /= 10; dignum++; } str[dignum] = 0; while (dignum>0) { dignum--; str[dignum] = num%10 + '0'; num /= 10; } }



unsigned int beginswith (char *A, char *B) { while (*A && *B) { if (*A != *B) break; A++; B++; } if (*A == 0) return 1; return 0; }



unsigned int IsAbuNacci(char *str) { int num1, num2, pos=0; char nextnum[N]; num1 = str[pos++] - '0'; num2 = str[pos++] - '0'; while(str[pos]) { num2str(num1+num2, nextnum); if (!beginswith(nextnum, str+pos)) return 0; pos += strlen(nextnum); num2 = num1+num2; num1 = num2-num1; } return 1; }

תרגול 9: מחרוזות ומבנים

Documents