פרק 8 - מחרוזות

‫קורס יסודות התכנות בשפת ‪C‬‬
‫פרק ‪8‬‬
‫מחרוזות ‪Strings -‬‬
‫ד"ר שייקה בילו‬

‫יועץ ומרצה בכיר למדעי המחשב וטכנולוגית מידע‬
‫מומחה למערכות מידע חינוכיות‪ ,‬אקדמיות ומנהליות‬
‫‪SCE-Chapter-8-Strings‬‬ ‫‪1‬‬ ‫‪Shayke Bilu PhD‬‬

‫חזרה ‪ -‬אתחול מערכים בשורת ההגדרה‬
‫‪2‬‬
‫;}‪int Arr[5]={0,1,2,3,4‬‬
‫‪ ‬ניתן לאתחל מערכים בצורה זו אך ורק בשורת ההגדרה‪.‬‬
‫‪ ‬הערכים מוצבים בתאים לפי הסדר החל מהתא הראשון‪.‬‬
‫‪ ‬אם אין מספיק ערכים‪ ,‬שאר התאים מאותחלים לערך ‪.0‬‬
‫;}‪int Arr[5]={1,2‬‬
‫;}‪int Arr[5]={0‬‬
‫‪ ‬אם לא נציין את מספר תאי המערך‪ ,‬הוא יהיה כמספר ערכי‬
‫האתחול (בדוגמא הבאה יהיו לו ‪ 6‬תאים)‪:‬‬
‫;}‪int Arr[]={1,2,3,4,5,6‬‬
‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬
‫חזרה ‪ -‬מערכים אחרי שורת ההגדרה‬
‫‪3‬‬
‫‪ ‬אחרי הגדרת המערך אפשר רק להתייחס לכל תא בנפרד‪.‬‬

‫‪ ‬אי‪-‬אפשר לשים ערכים בתאי המערך בבת‪-‬אחת‪:‬‬
‫למשל אי‪-‬אפשר לאפס בבת‪-‬אחת את כל התאים ע"י ‪Arr=0‬‬ ‫‪‬‬
‫צריך לעשות זאת ע"י לולאה‪:‬‬ ‫‪‬‬
‫)‪for(i=0; i<SIZE; i++‬‬
‫;‪Arr[i]=0‬‬
‫לא ניתן להעתיק מערך למערך אחר ע"י פעולת השמה ‪Arr1=Arr2‬‬ ‫‪‬‬
‫זה מחייב שימוש בלולאה‪:‬‬ ‫‪‬‬
‫)‪for(i=0; i<SIZE; i++‬‬
‫;]‪Arr[i]=Bll[i‬‬
‫‪ ‬כך גם לגבי פעולות השוואה‪ ,‬הדפסה‪ ,‬קלט‪ ,‬וכו'‬

‫חזרה ‪ -‬חריגה מגבולות המערך‬
‫‪4‬‬
‫‪#define SIZE 10‬‬ ‫‪ ‬הוגדר גודל מערך‪:‬‬

‫‪ ‬מותר לגשת לכל תא במערך לפי כתובתו‪.‬‬
‫‪ ‬אסור לגשת לתאים שנמצאים מחוץ למערך‪.‬‬
‫;]‪int arr[SIZE‬‬ ‫‪ ‬גישה לתא שנמצא מחוץ למערך תגרום לבעיות‪:‬‬
‫;‪int i = 0‬‬ ‫‪ ‬בסבירות גבוהה התוכנית תקרוס‪.‬‬
‫) ‪for ( i=0; i <= SIZE; i++‬‬ ‫‪ ‬או שהיא פשוט לא תעבוד כראוי‪.‬‬
‫{‬
‫;‪arr[i] = i‬‬ ‫‪ ‬למשל‪:‬‬
‫}‬
‫]‪ arr[10‬לא שייך למערך!‬

‫חזרה ‪ -‬נקודה תשומת‪-‬לב‬
‫‪5‬‬
‫‪ ‬גודל מערך יכול להיות קבוע שמוגדר ב‪( #define -‬כי זה מספר‬
‫המוגדר גלובלית אינו יכול להשתנות במהלך הריצה)‪.‬‬
‫‪#define SIZE 10‬‬
‫;]‪int arr[SIZE‬‬
‫‪ ‬בהגדרת מערך הגודל שלו חייב להיות מספר קבוע‪ ,‬או משתנה‬
‫גלובלי ולא יכול להיות ערך של משתנה‪.‬‬
‫‪ ‬למשל‪:‬‬
‫;]‪int arr[10‬‬ ‫;]‪//int arr[SIZE‬‬
‫;‪int my_size=10‬‬ ‫ולא‪:‬‬
‫;]‪int arr[my_size‬‬

‫ דוגמא‬- ‫ מערכים‬- ‫חזרה‬
6
#include <stdio.h>
‫התוכנית קולטת מספר שלם חיובי ומדפיסה כמה‬
#define SIZE 10
int main() ‫פעמים הופיעה בו כל סיפרה‬
{
int i, num, digits[SIZE]={0};
printf(“Enter a positive integer:\n”);
scanf(“%d”, &num);
while (num!=0) ‫ במערך‬i ‫בכתובת אותה מציין תא‬
{
digits[num%10]++; ‫יופיע מספר המייצג את מספר ההופעות‬
num=num/10;
} num ‫ במספר‬i ‫של הספרה‬
for (i=0; i<SIZE; i++)
printf(“Digit %d appeared %d times\n”,i,digits[i]);
}
SCE-Chapter-8-Strings Shayke Bilu PhD

‫חזרה ‪ -‬העברת מערך לפונקציה‬
‫‪7‬‬
‫‪ ‬נדגים פונקציה שמקבלת מערך של מספרים שלמים ומחזירה את‬

‫סכום המספרים במערך‪.‬‬
‫‪ ‬הקריאה לפונקציה‪:‬‬
‫;)‪sum = calc_sum(array‬‬
‫‪ ‬כותרת הפונקציה‪:‬‬
‫;)] [‪int calc_sum(int array‬‬
‫‪ ‬אין צורך חובה לציין את גודל המערך בתוך ה‪ ] [ -‬בכותרת הפונקציה‪.‬‬
‫‪ ‬אין צורך להעביר את גודל המערך במידה והוא הוגדר כמשתנה גלובלי‪.‬‬
‫‪ ‬סימון ה‪ ] [ -‬מציין היות המשתנה מערך לוקאלי לפונקציה זו בלבד !!!‬

‫ פונקציה שמסכמת מערך‬- ‫חזרה‬
8
#include <stdio.h>
#define SIZE 10
int calc_sum(int arr[]) ‫פונקציית הסכום‬
{
int i, sum = 0; ,‫עוברים על תאי המערך בלולאה‬
for(i=0; i<SIZE; i++) ‫מסכמים אותם לתוך משתנה סוכם‬
sum=sum+arr[i];
return sum; ‫כאשר בסיום ומחזירים את הסכום‬
}
int main()
{
int input[SIZE], i;
for(i=0; i<SIZE; i++)
scanf("%d", &input[i]); ‫קליטת המערך‬
printf("The sum is %d\n", calc_sum(input, 10));
return 0; ‫קריאה לפונקציה‬
}
‫ פונקציית סכום איברים‬- ‫חזרה‬
9
int sumf(int arr[])

}
int sum=0,i;
for(i=0 ; i<SIZE ; ++i)
sum+=arr[i];
printf("The sum of array is : %d\n", sum);
{

‫חזרה ‪ -‬העברת משתנים קבועים לפונקציה‬
‫‪10‬‬
‫‪ ‬אפשר להגדיר משתני קלט בפונקציה כקבועים (‪.)const‬‬

‫‪ ‬כך נוכל להבטיח שלא נשנה בטעות את ערך המשתנה‪.‬‬
‫‪ ‬הכי שימושי כאשר אנו מעבירים מערך לפונקציה‪.‬‬
‫‪ ‬לא ניתן להעביר מערך שהוגדר כקבוע (‪ )const‬לפונקציה שבה הוא‬
‫לא קבוע ועלול להשתנות‪.‬‬
‫)][‪void print_array(const int array‬‬
‫{‬
‫;‪int i = 0‬‬
‫) ‪for( i=0; i<SIZE; i++‬‬
‫;)]‪printf("%3d",array[i‬‬
‫;)"‪printf("\n‬‬
‫{‬
‫ פונקציה המקבלת מערך דו ממדי‬- ‫חזרה‬
11
void printArrayZogi(int a[ ][ COLUMN ])

{
int i, j;
for ( i = 0; i < ROW; i++ ) ‫מעבר על השורות‬
{
for ( j = 0; j < COLUMN; j++ ) ‫מעבר על עמודות‬
if(a[i][j] % 2 == 0) ‫הדפסת איברי השורה‬
printf( "%4d", a[i][j]); ‫הזוגיים בלבד‬
printf( "\n" );
}
}
‫ תוכנית השולחת לפונקציה‬- ‫חזרה‬
‫מערך דו ממדי המודפס בתוכה‬
12
#include <stdio.h>
#define ROW 3
#define COLUMN 4
void printArray(int [ ][ COLUMN ]);
int main()
{
int array1[ ROW ][ COLUMN ] = {{1,2,3,4},
{5,6,7,8},
{9,10,11,12}};
printf( "Values in array1 by row are:\n" );
printArray( array1);
return 0;
}
‫ תוכנית השולחת לפונקציה‬- ‫חזרה‬
‫מערך דו ממדי המודפס בתוכה‬
13
void printArray(int a[ ][ COLUMN ])

{
int i, j;
for ( i = 0; i < ROW; i++ )
{
for ( j = 0; j < COLUMN; j++ )
printf( "%4d", a[ i ][ j ] );
printf( "\n" );
}
}
14
?‫שאלות‬

‫תרגיל ‪ - 2‬חיפוש במערכים (לינארי)‬
‫‪15‬‬
‫במקרה זה נתון מערך ממוין שנרצה לחפש בו איבר כלשהו‪.‬‬

‫‪ ‬חיפוש ליניארי הוא חיפוש קווי סודר לאורך נתונים המערך בכפוף‬
‫לתנועה ע"י שימוש באינדקס‪.‬‬
‫‪5‬‬ ‫‪8‬‬ ‫‪9 12 15 17 20 21 24 27 29 31‬‬
‫במקרה זה נחפש את הערך ‪ 17‬במערך ע"י חיפוש רגיל‪ ,‬לינארי‪,‬‬

‫תוך כדי מעבר על כל איברי המערך מהאיבר הראשון לאחרון עד‬
‫למציאתו או לאי מציאתו במערך‬

‫פתרון חיפוש לינארי במערכים‬
16
#include <stdio.h>
#define SIZE 5
int linarySearch(int arr[], int item )
{
int i;
for(i=0;i<SIZE;i++)
{
if (arr[i] == item)
{
printf(“The item %d in place %d”,arr[i], i+1);
return 1;
}
}
return 0;
}
‫התוכנית הראשית‬
17
int main()
{
int arr[SIZE]={1,2,3,4,5},item=5,status=0;
status=linarySearch( arr,item);
if(status == 1)
printf(“Item is found in array!!!\n");
else
printf(“Item is not found in array!!!\n");
return 0;
}
‫תרגיל ‪ - 3‬חיפוש במערכים (בינארי)‬
‫‪18‬‬
‫נתון מערך ממוין נרצה לחפש בו איבר כלשהו‪.‬‬

‫‪ ‬חיפוש בינארי הוא חיפוש לאורך המערך תוך כדי חלוקתו לחצי‬
‫והגדרת תחום ימני ותחום שמאלי המשתנים לפי התקדמות‬
‫החיפוש‪.‬‬
‫‪5‬‬ ‫‪8‬‬ ‫‪9 12 15 17 20 21 24 27 29 31‬‬
‫נחפש את ‪ 24‬בחיפוש בינארי בתוך המערך ע"י חלוקת כמות‬

‫איברי המערך כל פעם לחצי תוך כדי בדיקת היחס בין המספר אותו‬
‫מחפשים לבין הערך המספרי במערך העומד באמצע‪.‬‬
‫תרגיל ‪ - 3‬חיפוש במערכים‬
‫‪19‬‬
‫‪5‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪12 15 17 20 21 23 24 29 31‬‬
‫נחפש את ‪ 24‬חיפוש בינארי ע"י חלוקת המערך כל חיפוש לחצי‬

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

‫פתרון חיפוש בינארי במערכים‬
20
#include <stdio.h>
#define SIZE 10
int binarySearch(int arr[ ], int item )
{
int lsize=0, rsize=SIZE-1, middle;
while ( lsize <= rsize )
{
middle = (rsize + lsize ) / 2;
if ( item == arr[ middle ] ) return 1;
if ( item < arr[ middle ] )
rsize = middle-1;
else
lsize = middle+1;
}
return 0; }
21
int main()
{
int arr[SIZE]={1,2,3,4,5,6,7,8,9,10};
int item=5, status=0;
status=binarySearch(arr,item);
if(status == 1)
printf(“Item is found in array!!!\n");
else
printf(“Item is not found in array!!!\n");
return 0;
}
22
?‫שאלות על השעור הקודם‬

‫נושאי הפרק מחרוזות‬
‫‪23‬‬
‫‪ ‬הגדרת מחרוזת‪.‬‬
‫‪ ‬אתחול מחרוזת וסימון סוף מחרוזת‪.‬‬
‫‪ ‬קלט‪/‬פלט של מחרוזות‪.‬‬
‫‪ ‬פעולות על מחרוזות‪.‬‬
‫‪ ‬מציאת אורך מחרוזת‪.‬‬
‫‪ ‬איתור תו במחרוזת‪.‬‬
‫‪ ‬פונקציות פנימיות על מחרוזות‪.‬‬
‫‪ ‬פונקציות פנימיות על תווים‪.‬‬
‫‪ ‬מערכים דו ממדיים ומחרוזות‪.‬‬
‫מחרוזות‬
‫‪24‬‬
‫מחרוזת היא רצף תווים בעל משמעות כלשהי (למשל מילה או‬ ‫‪‬‬
‫משפט)‪.‬‬
‫לשמירת מחרוזת בזיכרון נשתמש באופן טבעי במערך של תווים‪.‬‬ ‫‪‬‬
‫למשל‪:‬‬ ‫‪‬‬
‫;]‪char word[SIZE‬‬
‫‪ ‬אבל בהרבה מקרים נתייחס אל מחרוזת בבת‪-‬אחת‪ ,‬ולא רק‬
‫כמערך של תווים (למשל לקלוט מילה בבת‪-‬אחת ולא תו‪-‬תו)‪.‬‬
‫‪ ‬כמו‪-‬כן‪ ,‬במקרים רבים אורך המחרוזת לא ידוע מראש (יתכן‬
‫שנקבל מהקלט מילה קצרה יותר מגודל המערך)‪.‬‬
‫נכיר היום פקודות ופונקציות‪-‬ספריה שכבר נכתבו במיוחד לצורך‬ ‫‪‬‬
‫עבודה עם מחרוזות‪ ,‬ומאפשרות להתגבר על הבעיות האלה‪.‬‬
‫מחרוזות – אתחול‬
‫‪25‬‬
‫‪ ‬לדוגמא‪ ,‬יש דרך טבעית יותר לאתחל מערך שמייצג מחרוזת‬

‫(במקום לרשום את התווים מופרדים בפסיקים)‪:‬‬
‫;”‪char message[ ]=“Hello dear C student‬‬
‫‪ ‬שימו לב שמשתמשים כאן בגרשיים כפולים " "‪ ,‬ולא בגרשיים‬
‫בודדים ' ' כמו שעשינו עבור תו בודד‪.‬‬
‫‪ ‬בהמשך נבחין שייצוג מחרוזת קבועה נעשה תמיד ע"י גרשיים כפולים‪.‬‬
‫‪ ‬ייצוג תווים בודדים כחלק ממחרוזת יעשה ע"י השמתם בתוך גרשים ' '‪.‬‬
‫‪ ‬זהו ההבדל בין קליטת מילה (בין גרשיים) לבין קליטת תו בין גרשים‪.‬‬

‫סימון סוף המחרוזת‪ :‬התו המיוחד '‪'\0‬‬
‫‪26‬‬
‫‪ ‬בכל הפקודות והפעולות הקיימות לגבי מחרוזות‪ ,‬יש מוסכמה‬

‫שלפיה בסוף תווי המחרוזת מופיע במערך התו '‪'\0‬‬
‫‪ ‬תו זה משמעותו סיום המחרוזת (מקום ‪ 0‬ב‪)ASCII -‬‬
‫‪‘H’ ‘E’ ‘L’ ‘L’ ‘O’ ‘\0’ .‬‬ ‫‪.‬‬ ‫‪.‬‬ ‫‪.‬‬
‫]‪str[0‬‬ ‫]‪str[9‬‬
‫‪ ‬הכנסת התו מאפשרת לבצע פעולות על מחרוזת בלי לדעת‬

‫מראש את אורכה‪.‬‬
‫‪ ‬ברגע שמגיעים לתו ‪ \0‬יודעים שהמחרוזת הסתיימה‪.‬‬

‫סימון סוף המחרוזת‪ :‬התו המיוחד '‪'\0‬‬
‫‪27‬‬
‫‪ ‬כל הפעולות שנכיר על מחרוזות דואגות בעצמן לשמירת‬

‫המוסכמה הזו של תו הסיום‪.‬‬
‫‪ ‬למשל פעולת האתחול הזו‪:‬‬
‫;”‪char word[ ]=“HELLO‬‬
‫‪ ‬שקולה לפעולת האתחול הזו‪:‬‬
‫;}’‪char word[ ]={‘H’,’E’,’L’,’L’,’O’,’\0‬‬
‫‪ ‬מחרוזת באורך ‪ 5‬דורשת מערך של ‪ 6‬תווים‪.‬‬
‫’‪‘H’ ‘E’ ‘L’ ‘L’ ‘O’ ‘\0‬‬

‫]‪word[0‬‬ ‫]‪word[5‬‬
‫הוספת תו הסיום '‪'\0‬‬
‫‪28‬‬
‫‪ ‬במידה וקיים ערך של תווים ללא תו סיום‪ ,‬ורוצים להפעיל עליו‬

‫פעולות על מחרוזות (שנכיר בהמשך)‪ ,‬אז צריך להוסיף את התו‬
‫'‪ '\0‬אחרי תווי‪-‬המחרוזת‪.‬‬
‫‪ ‬למשל אם נבקש להשתמש בפעולות על מחרוזות עבור המערך‪:‬‬
‫;}’‪char word[ ]={‘H’,’E’,’L’,’L’,’O’,’\0‬‬
‫‪ ‬אז נצטרך להוסיף את התו '‪ '\0‬אחרי האות '‪ 'O‬על‪-‬ידי השמה‪:‬‬
‫;’‪word[5]=‘\0‬‬
‫’‪‘H’ ‘E’ ‘L’ ‘L’ ‘O’ ‘\0‬‬
‫]‪word[0‬‬ ‫]‪word[5‬‬
‫דוגמא‪ :‬מציאת אורך מחרוזת‬
‫‪29‬‬
‫‪ ‬הפונקציה הבאה מקבלת מחרוזת ומחזירה את האורך שלה‪ ,‬בהסתמך על‬

‫כך שיש תו '‪ '\0‬בסוף המחרוזת‪.‬‬
‫)] [‪int my_strlen(char str‬‬
‫{‬
‫;‪int cnt=0,i=0‬‬
‫)'‪while (str[i ++] != '\0‬‬
‫;‪cnt++‬‬
‫;‪return cnt‬‬
‫}‬
‫‪ ‬המשתנה ‪ i‬מאותחל בערך ‪ 0‬והוא זקיף הלולאה‪ ,‬המשתנה ‪ cnt‬מאותחל‬
‫ב‪ 0 -‬והוא מונה התווים שבמילה‪ ,‬כאשר התו במחרוזת שווה ל‪'\0' -‬‬
‫סימן שהמחרוזת הסתיימה וכך גם הלולאה‪.‬‬
‫‪ ‬הפונקציה מחזירה לתוכנית הראשית את ערכו של ‪ cnt‬שהוא מספר‬
‫התווים במחרוזת‪.‬‬
‫סיכום ביניים ‪ -‬מחרוזות‬
‫‪30‬‬
‫• הגדרת מחרוזת‬
‫• גבול מחרוזת‬
‫• אתחול מחרוזת‬
‫תו סיום '‪'\0‬‬ ‫•‬
‫• מציאת אורך מחרוזת‬

31
?‫שאלות‬

‫קלט‪/‬פלט של מחרוזות תו אחרי תו‬
‫‪32‬‬
‫‪ ‬ניתן לקלוט ולהדפיס את תווי המחרוזת בזה‪-‬אחר‪-‬זה‪ ,‬בעזרת‬

‫הפונקציות כאשר יש להקפיד על השימוש ב‪:%c -‬‬
‫) (‪scanf( ) , printf‬‬
‫‪ ‬ניתן גם לבצע קליטה והדפסה של תווי מחרוזת באמצעות‬
‫הפונקציות הבאות הקולטות תו בודד אך הן מחייבות לולאה‬
‫לביצוע מתמשך‪:‬‬
‫( )‪getchar( ), putchar‬‬
‫‪ ‬בשקף הבא תוצג תוכנית הקולטת מחרוזת באורך ‪ 200‬תווים לכל‬
‫היותר‪ ,‬תו אחרי תו ומפסיקה אם נקלטת ירידת‪-‬שורה‪.‬‬
‫‪ ‬לשם השימוש בפונקציות הנ"ל יש לזמן את ספריית ה‪string.h -‬‬
‫קלט של מחרוזות תו אחרי תו‬
‫‪33‬‬
‫>‪#include <stdio.h‬‬
‫‪#define SIZE 201‬‬
‫)(‪int main‬‬ ‫הגדרת גודל מערך ‪ 200 -‬תווים ומשתנה לקליטת התו‬
‫{‬
‫;‪char sentence[SIZE], tav‬‬
‫;‪int i=0‬‬
‫{ ‪do‬‬ ‫קולטים תו במסגרת הלולאה‬
‫;)(‪scanf(“%c”, &tav);//tav=getchar‬‬
‫)’‪if (tav != ‘\n‬‬ ‫אם זה לא תו ירידת‪-‬שורה אז יש להוסיף‬
‫{‬ ‫אותו למקום הבא במחרוזת ומקדמים את‬
‫;‪sentence[ i ] = tav‬‬ ‫הזקיף‬
‫;‪i++‬‬
‫}‬
‫; )’‪} while (tav != ‘\n‬‬ ‫התנאי להמשך הקלט‬
‫פלט של מחרוזות תו אחרי תו‬
‫‪34‬‬
‫;’‪sentence[ i ]=‘\0‬‬ ‫סימון סיום המחרוזת‬

‫;‪i=0‬‬ ‫איפוס הזקיף לסימון התחלת המחרוזת‬
‫‪do‬‬
‫{‬
‫;) ] ‪printf)“%c”, sentence[ i‬‬ ‫הדפסת התו במסך‬
‫;‪i++‬‬ ‫קידום הזקיף לכתובת התא הבא במחרוזת‬
‫; )’‪} while ( sentence[ i ] != ‘\0‬‬
‫;‪return 0‬‬ ‫בדיקת אי קיום סוף מחרוזת להמשך ההדפסה‬
‫}‬
‫קלט‪/‬פלט של מחרוזת שלמה‬
‫‪35‬‬
‫‪ ‬אפשר גם לקלוט ולהדפיס מחרוזות בבת‪-‬אחת על ידי שימוש בפונקציות‬

‫הקלט פלט‪ scanf(), printf )( :‬באמצעות הקידוד ”‪.“%s‬‬
‫‪ ‬למשל‪:‬‬
‫;]‪char answer[SIZE‬‬
‫;)‪scanf(“%s”, answer‬‬
‫‪ ‬הקלט יהיה רק עד רווח או ירידת‪-‬שורה‪ ,‬זו הדרך לקליטת מילים‬
‫בלבד ולא משפטים‪.‬‬
‫‪ ‬התו '‪ '\0‬מוכנס אוטומטית ע"י ה‪ scanf)( -‬אחרי תווי המחרוזת‬
‫ע"י ההקלדה על מקש ה‪.Enter -‬‬
‫‪ ‬שימו לב שלא רושמים את הסימן & ב‪ scanf -‬של מחרוזת‬
‫שלמה‪ .‬אין צורך לרשום & כי שם המערך הוא מצביע לכתובת‬
‫התו הראשון של המחרוזת כולה‪.‬‬

‫קלט של מחרוזת שלמה – הגבלת מס' תווים‬
‫‪36‬‬
‫כשתוכנס מחרוזת ארוכה יותר מהגודל שהגדרנו למערך‪ ,‬התוכנית‬ ‫‪‬‬

‫צפויה "לעוף"‪ ,‬כי תהיה גלישה מעבר לגבול המערך כפי שהוגדר‪.‬‬
‫יש לזכור כי צריך להשאיר מקום אחד נוסף עבור תו הסיום‪ ,‬לכן‬ ‫‪‬‬
‫הפונקציה( ) ‪ scanf‬תקלוט מחרוזת עד תו רווח בלבד‪.‬‬
‫במידה ורוצים להגביל את מספר התווים שיקלטו ניתן להגדיר זאת‬ ‫‪‬‬
‫ב‪.scanf) ( -‬‬
‫;)‪scanf(“%40s”, answer‬‬ ‫למשל‪:‬‬ ‫‪‬‬
‫דרך נוספת להגבלת מספר התווים הנקלטים היא לבצע לולאה ולקלוט‬
‫תו אחרי תו‪ ,‬הקלט לא נפסק כשמגיעים לרווח אלא רק כאשר נקלט‬
‫סימן ירידת השורה "‪."\n‬‬
‫פלט של מחרוזת שלמה‬
‫‪37‬‬
‫‪ ‬הפקודה הבאה תדפיס את תווי המחרוזת ‪ answer‬עד לתו '‪.'\0‬‬

‫)‪printf(“%s”, answer‬‬
‫‪HELLO‬‬
‫‪ ‬אם בטעות אין תו '‪ '\0‬בסוף המחרוזת‪ ,‬אז ‪ printf‬תדפיס גם את‬
‫מה שיש אחרי המחרוזת בזיכרון‪ ,‬עד שיגיע במקרה לתו '‪.'\0‬‬
‫‪ ‬בפועל יודפס אחרי המחרוזת רצף של תווים‪" -‬זבל דיגיטלי"‪.‬‬
‫‪ ‬למשל‪:‬‬
‫!^&‪HELLO╠╠╠╠╠Z╠╠▲¢F╢+╪■$▲@#‬‬
‫אפשרות לקלט מחרוזות בשלמות‬
‫‪38‬‬
‫‪ ‬פקודת קלט נוספת למחרוזות שקולטת מחרוזת תווים כולל רווח‪:‬‬

‫;)‪gets(str‬‬
‫‪ ‬הפונקציה פועלת בדיוק כמו )‪ , scnaf(“%s”,str‬כלומר קולטת‬
‫מחרוזת שלמה מהמסך כולל תווי רווח במחרוזת‪.‬‬
‫‪ ‬היתרון ‪ -‬המהירות‪ ,‬הכתיבה הקצרה יותר והנוחות הנגזרת מכך‪.‬‬
‫‪ ‬החיסרון ‪ -‬לא ניתן להגביל את אורך מחרוזת הקלט‪ ,‬במידה‬
‫והמשתמש יכניס מחרוזת ארוכה מידי התוכנית "תעוף"‪ .‬ניתן‬
‫לקלוט רק מחרוזת אחת בלבד‪.‬‬

‫אפשרות לפלט מחרוזות בשלמות‬
‫‪39‬‬
‫‪ ‬פקודת פלט תואמת המבצעת הדפסה וירידת שורה‪:‬‬

‫;)‪puts(str‬‬
‫‪ ‬הפונקציה פועלת בדיוק כמו )‪ ,printf(“%s\n”,str‬כלומר מדפיסה‬
‫מחרוזת שלמה ולאחריה מבצעת ירידת שורה‪.‬‬
‫‪ ‬היתרון ‪ -‬המהירות‪ ,‬הכתיבה הקצרה יותר והנוחות הנגזרת מכך‪.‬‬
‫‪ ‬החיסרון ‪ -‬לא ניתן להגביל את אורך מחרוזת הפלט‪ .‬לא ניתן להציג‬
‫באותה פקודה גם מחרוזת טקסט נוספת אלא רק אחת‪ .‬ניתן להדפיס‬
‫רק מחרוזת אחת בלבד‪.‬‬

‫סיכום ביניים קלט‪/‬פלט של מחרוזות‬
‫‪40‬‬
‫קלט תו‪-‬תו בלולאה‬ ‫•‬

‫קלט של מחרוזת שלמה‬ ‫•‬
‫• קביעת אורך מחרוזת נקלטת‬
‫קלט פלט מחרוזות באמצעות‬ ‫•‬
‫שימוש בפונקציות‬

41
?‫שאלות‬

‫פעולות על מחרוזות‬
‫‪42‬‬
‫‪ ‬לא ניתן לבצע פעולות השוואה והשמה על מחרוזת שלמה‪:‬‬
‫‪string1==string2‬‬
‫‪string1=string2‬‬
‫‪string1>=string2‬‬
‫הסיבה לכך היא שכמו במערכים‪ ,‬שם המחרוזת הוא מצביע המכיל‬
‫את הכתובת שלה בזיכרון‪ ,‬לכן גם פעולות אלה יבוצעו על‬
‫הכתובות ולא על תוכן המחרוזת‪.‬‬

‫פעולות על מחרוזות‬
‫‪43‬‬
‫לביצוע פעולות על מחרוזת שלמה יש צורך להשתמש בפונקציות‬ ‫‪‬‬

‫הנמצאות בספריה‪string.h :‬‬
‫הספריה כוללת פונקציות המשמשות להשוואת מחרוזות‪ ,‬העתקת‬ ‫‪‬‬
‫מחרוזות‪ ,‬הוספת מחרוזת למחרוזת אחרת ("שרשור")‪ ,‬ועוד‪....‬‬
‫יש לזכור כי כל מחרוזת היא מערך רגיל ההבדל הוא שהוא מערך‬ ‫‪‬‬
‫מטיפוס ‪ char‬ולכן ניתן להפעיל על המחרוזת את אוסף הפונקציות‬
‫הספציפיות עבורה‪.‬‬
‫הפונקציות המחרזותיות נחלקות לשלושה סוגים עיקריים‪:‬‬ ‫‪‬‬
‫כאלה המבצעות בדיקה ומחזירות תשובה של אמת או שקר קיים או לא‬ ‫‪.1‬‬
‫קיים‪.‬‬
‫כאלה המחזירות תשובה מספרית קבועה כגון ערך או ‪ 1‬או ‪ 1-‬או ‪ 0‬וכדומה‪.‬‬ ‫‪.2‬‬
‫כאלה המבצעות פעולה ומשנות בפועל את תוכן המחרוזת‪.‬‬ ‫‪.3‬‬

‫הספריה ‪ – string.h‬פונקציות לדוגמא‬
‫‪44‬‬
‫פונקציה המבצעת מציאת אורך מחרוזת‪:‬‬
‫;)] [‪int strlen(char str‬‬ ‫האורך לא כולל את התו '‪'\0‬‬
‫;)‪strlen(str‬‬ ‫‪ ‬ביצוע הפונקציה‪:‬‬
‫‪ ‬הפונקציה מחזירה את אורך המחרוזת‪ ,‬כלומר את מספר התווים‬
‫במחרוזת עד תו ה‪.'\0' -‬‬
‫‪ ‬השימוש מתבצע כך‪:‬‬
‫;)‪len = strlen(my_string‬‬
‫‪ ‬אל המשתנה ‪ len‬יוחזר אורך המחרוזת ‪my_string‬‬

‫‪45‬‬
‫‪ ‬פונקציה המבצעת השוואה בין מחרוזות‪:‬‬
‫;)] [‪int strcmp(char str1[ ], char str2‬‬
‫;)‪result = strcmp(str1,str2‬‬ ‫‪ ‬ביצוע הפונקציה‪:‬‬
‫‪ ‬הפונקציה בודקת את תווי שתי המחרוזות באופן מקביל אחת מול‬
‫השנייה ומחזירה את הערך ‪ 0‬רק אם המחרוזות זהות‪ ,‬כלומר שוות‬
‫בכל תו עד לתו '‪ ,'\0‬אחרת היא מחזירה מס' שונה מ‪:0-‬‬
‫‪ ‬חיובי (‪ )1‬אם המחרוזת הראשונה גדולה יותר לפי ‪. ASCII -‬‬
‫‪ ‬שלילי (‪ )-1‬אם המחרוזת הראשונה קטנה יותר לפי ‪. ASCII -‬‬
?‫ מה עושה התוכנית הבאה‬:‫דוגמא‬
46
#include <stdio.h>
#include <string.h>
#define SIZE 7
int main()
}
int Obama_votes = 0 , Romney_votes=0;
char vote[SIZE];
while(1)
}
printf(“Please enter your vote:)Obama or Romney)\n");
printf(“Enter Stop for exit program\n");
scanf("%s", vote);
?‫ מה עושה התוכנית הבאה‬:‫דוגמא‬
47
if (strcmp(vote, "Obama")==0) ‫התוכנית קולטת בחירות של‬
Obama_votes++; ‫בוחרים ומונה את ההצבעות‬
else .‫לאובמה ורומני‬
if (strcmp(vote, "Romney")==0) ‫במידה ויש טעות הקלדה מבקשים‬
Romney_votes++; .‫קלט חדש‬
else stop ‫כל זה עד שנקלטת המילה‬
if (strcmp(vote, "Stop")==0) .‫ועוצרת את הקליטה‬
break;
‫אחרי העצירה מודפסות התוצאות‬
else .‫של הבחירות‬
printf("Wrong vote !!!\n");
{
printf("Obama received %d votes and Romney received %d
votes\n",Obama_votes, Romney_votes);
{
‫הפונקציה – )‪atoi(str‬‬
‫‪48‬‬
‫‪ ‬פונקציה המבצעת הפיכה של מחרוזת למספר שלם‪:‬‬

‫‪ ‬הגדרה במחשב‪:‬‬
‫>‪#include <stdlib.h‬‬
‫;) ‪int atoi(const char *str‬‬
‫‪ ‬הפונקציה מקבלת משתנה מטיפוס תווי ‪ char‬ומחזירה ערך שלם‬
‫‪ int‬עד זיהוי תו‪ ,‬אז נעצרת פעולתה‪.‬‬
‫;‪int i‬‬
‫;)"‪i = atoi("512.035‬‬
‫;)‪printf(“i=%d”,i‬‬
‫על המסך נקבל את התוצאה‪512 :‬‬
atoi(str) – ‫שימוש בפונקציה‬
49
:‫ הפונקציה המבצעת הפיכה של תו למספר שלם‬
‫ הפונקציה‬int atoi(const char &str[i]); :‫ הגדרת הפונקציה במחשב‬
.i ‫ החל מהכתובת של‬int ‫ ומחזירה ערך שלם‬char ‫מקבלת משתנה תווי‬
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define SIZE 81 Num = 218 :‫על המסך נקבל את הפלט‬
void main()
{
int num, i=6;
char str[SIZE] = {"Shizaf218/2"};
num = atoi(&str[i]);
printf("Num = %d\n", num);
}
atoi(str) – ‫דוגמה לשימוש בפונקציה‬
50
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main()
}
char str1[]={'1','6','.','7','$','\0'};
char str2[]={“91.8FM”};
int mispar1,mispar2;
mispar1 = atoi(&str1[1]);
puts(str1);
printf("Mispar1=%d\n",mispar1);
mispar2 = atoi(str2);
puts(str2);
printf("Mispar2=%d\n",mispar2);
}
‫‪51‬‬
‫‪ ‬פונקציה המבצעת הפיכה של תווי המחרוזת לאותיות גדולות‪:‬‬
‫;)] [‪void strupr(char str‬‬
‫‪ ‬ביצוע הפונקציה‪ strupr(str); :‬יגרום לכך שבתוך המחרוזת ‪str‬‬

‫כל האותיות יהפכו לאותיות גדולות‪.‬‬
‫‪ ‬לדוגמה‪ :‬במידה ובמחרוזת ‪ str‬קיים המשפט‪"shalom friend" :‬‬

‫לאחר ביצוע הפונקציה )‪ strupr(str‬נקבל בתוך הפונקציה את‬
‫המחרוזת‪"SHALOM FRIEND" :‬‬

‫‪52‬‬
‫‪ ‬פונקציה המבצעת הפיכה של תווי המחרוזת לאותיות קטנות‪:‬‬
‫;)] [‪void strlwr(char str‬‬
‫‪ ‬ביצוע הפונקציה‪ strlwr(str); :‬יגרום לכך שבתוך המחרוזת‬

‫‪ str‬כל האותיות יהפכו לאותיות גדולות‪.‬‬
‫‪ ‬לדוגמה‪ :‬במידה ובמחרוזת ‪ str‬קיים המשפט‪:‬‬

‫"‪"SHALOM FRIEND‬‬
‫‪ ‬לאחר ביצוע הפונקציה )‪ strlwr(str‬נקבל בתוך הפונקציה את‬

‫המחרוזת "‪"shalom friend‬‬

‫‪53‬‬
‫‪ ‬פונקציה המבצעת הפיכה שכפול של המחרוזת‪:‬‬

‫;)] [‪char strdup(char str‬‬
‫‪ ‬ביצוע הפונקציה‪ strdup(str); :‬יגרום לכך שהכתובת של המחרוזת‬
‫‪ str‬תועבר למשתנה המקבל את הפונקציה‪.‬‬
‫‪ ‬לדוגמה‪ :‬במידה ובמחרוזת ‪ str‬קיימת המילה "‪"SHALOM‬‬
‫ונבצע את הפקודה הבאה‪ *p=strdup(str); :‬לאחר ביצוע הפקודה‬
‫במידה ונרצה להדפיס את תוכן המצביע ‪ *p‬נקבל את "‪"SHALOM‬‬
‫שהוא התוכן של המחרוזת ‪ str‬הנמצאת עכשיו גם בתוך המצביע ‪.*p‬‬

‫ – פונקציות לדוגמא‬string.h ‫הספריה‬
54
#include <stdio.h>
#include <string.h>
void main()
{
char *str = "This is a copy"; char *nstr;
// Make nstr point to a duplicate of string
nstr = strdup(str);
printf("The new string is: %s in %p\n", nstr,&nstr);
printf("The old string is: %s in %p\n", str,&str);
// Make nstr lower chars
nstr = strlwr(nstr);
printf("The new string is: %s\n", nstr);
// Make nstr uper chars
nstr = strupr(nstr);
printf("The new string is: %s\n", nstr);
}
55
:‫על המסך נקבל את התצוגה הבאה‬
The new string is: This is a copy in 0031F8A4

The old string is: This is a copy in 0031F8B0
The new string is: this is a copy
The new string is: THIS IS A COPY

‫‪56‬‬
‫‪ ‬פונקציה המבצעת העתקת מחרוזת למחרוזת אחרת‪:‬‬

‫;)] [‪void strcpy(char str1 [ ], char str2‬‬
‫‪ ‬ביצוע הפונקציה ;)‪ strcpy(str1,str2‬יגרום לכך שלתוך המחרוזת‬
‫‪ str1‬יועתק תוכן המחרוזת ‪.str2‬‬
‫‪ ‬במידה ובתוך המחרוזת ‪ str1‬היו תווים הם נדרסים‪.‬‬
‫‪ ‬לדוגמה‪ :‬במידה ובמחרוזת ‪ str1‬קיימת המילה "‪"shalom‬‬
‫ובמחרוזת ‪ str2‬קיימת המילה "‪ "friend‬לאחר ביצוע הפונקציה‬
‫בשתי המחרוזות המילים תהינה זהות בתוכנן‪:‬‬
‫"‪"friend‬‬
‫‪57‬‬
‫‪ ‬פונקציה המבצעת שרשור מחרוזות אחת אחרי השנייה‪:‬‬

‫;)] [‪void strcat(char str1[ ], char str2‬‬
‫‪ ‬ביצוע הפונקציה ;)‪ strcat(str1,str2‬יגרום לכך שבתוך המחרוזת‬
‫‪ str1‬יופיע תוכן המחרוזת ‪ str2‬בצמוד ומיד לאחר התוכן של‬
‫‪.str1‬‬
‫‪ ‬לדוגמה‪ :‬במידה ובמחרוזת ‪ str1‬קיים המשפט‪"shalom dear " :‬‬
‫ובמחרוזת ‪ str2‬קיימת המילה "‪ "friend‬לאחר ביצוע פונקציית‬
‫השרשור אל ‪ str1‬המחרוזת ‪ str1‬תכיל את המשפט‪:‬‬
‫”‪"shalom dear friend‬‬

‫‪58‬‬
‫‪ ‬פונקציה המבצעת הפיכה של מחרוזת מהסוף להתחלה‪:‬‬

‫;)] [‪void strrev(char str‬‬
‫‪ ‬ביצוע הפונקציה‪ strrev(str); :‬יגרום לכך שבתוך המחרוזת‬
‫‪ str‬סדר התווים יתהפך מהסוף להתחלה‪.‬‬
‫"‪"The string reverse‬‬
‫‪ ‬לאחר ביצוע הפונקציה )‪ strrev(str‬נקבל בתוך המחרוזת את‬
‫המשפט הפוך‪:‬‬
‫"‪"esrever gnirts ehT‬‬
59
#include <stdio.h>
#include <string.h>
#define SIZE 81
void main()
}
char str1[SIZE],str2[SIZE],str3[SIZE];
printf("Enter str1:\n");
gets(str1); strrev(str1);
printf("Str1:%s\n",str1);
gets(str2); strcpy(str1,str2);
printf("Str1:%s, Str2:%s\n",str1,str2);
gets(str3); strcat(str2,str3);
printf("Str2:%s, Str3:%s\n",str2,str3);
}
60
?‫שאלות‬

‫הספריה ‪ - string.h‬פונקציות מחרוזתיות‬
‫‪61‬‬
‫‪ ‬פונקציה המבצעת חיפוש של ההופעה הראשונה של תו במחרוזת‬

‫ומציגה את שאר המחרוזת החל מהמופע הראשון של התו‪:‬‬
‫;)‪char strchr(char str[ ], char ch‬‬
‫‪ ‬ביצוע הפונקציה ;)‪ strchr(str,ch‬יגרום לכך שיבוצע חיפוש של‬
‫התו שבמשתנה ‪ ch‬במחרוזת ‪ .str‬במידה והוא מופיע הפונקציה‬
‫תציג את המשך המחרוזת מהמקום בו הופיע התו כולל התו‪.‬‬
‫המחרוזת המקורית לא משתנה אלא רק התצוגה שלה‪.‬‬
‫"‪"shalom dear friend‬‬
‫ובמשתנה ‪ ch‬קיים התו ’‪ ‘d‬לאחר ביצוע הפונקציה תוחזר המחרוזת‪:‬‬
‫"‪"dear friend‬‬
‫‪62‬‬
‫‪ ‬פונקציה המבצעת חיפוש של המופע האחרון של תו במחרוזת‬
‫ומציגה את שאר המחרוזת מהמופע הראשון של התו‪:‬‬
‫;)‪char strrchr(char str[ ], char ch‬‬
‫‪ ‬ביצוע הפונקציה ;)‪ strrchr(str,ch‬יגרום לכך שיבוצע חיפוש של‬
‫התו שבמשתנה ‪ ch‬במחרוזת ‪ .str‬במידה והוא מופיע תוצג‬
‫המחרוזת החל מהמקום האחרון בו מופיע התו הראשון כולל התו‪.‬‬
‫המחרוזת המקורית לא משתנה אלא רק התצוגה שלה‪.‬‬
‫ובמשתנה ‪ ch‬קיים התו ’ ‘ לאחר ביצוע הפונקציה תוחזר המחרוזת‪:‬‬
‫"‪"friend‬‬
‫‪63‬‬
‫פונקציה המבצעת חיפוש ההופעה הראשונה של מחרוזת בתוך‬ ‫‪‬‬
‫מחרוזת אחרת ומציגה את שאר המחרוזת מהמופע הראשון של‬
‫המחרוזת שנמצאה‪:‬‬
‫;)] [‪char strstr(char str[ ], char find‬‬
‫ביצוע הפונקציה ;)‪ strstr(str,find‬יגרום לכך שיבוצע חיפוש של‬ ‫‪‬‬
‫המחרוזת שבמשתנה ‪ find‬במחרוזת ‪ .str‬במידה והיא מופיעה‬
‫הפונקציה תציג את ‪ str‬החל מהמקום בו מופיעה המחרוזת ‪.find‬‬
‫לדוגמה‪ :‬במידה ובמחרוזת ‪ str‬קיים המשפט‪:‬‬ ‫‪‬‬
‫ובמשתנה ‪ find‬קיימת המחרוזת "‪ "dear‬לאחר ביצוע הפונקציה‬ ‫‪‬‬
‫תוחזר המחרוזת‪:‬‬
‫"‪"dear friend‬‬
‫‪64‬‬
‫‪ ‬פונקציה המבצעת חיפוש של ההופעה הראשונה של מחרוזת מסוף‬

‫המחרוזת ומקצצת מהמקום בו נמצא המופע הראשון‬
‫;)] [‪char strtok(char str[ ], char find‬‬
‫‪ ‬ביצוע הפונקציה ;)‪ strtok(str,find‬יגרום לכך שיבוצע חיפוש של‬
‫המחרוזת הנמצאת במשתנה ‪ find‬בתוך המחרוזת ‪ .str‬במידה והיא‬
‫מופיעה הפונקציה תחזיר את המחרוזת מהסוף ועד המקום בו מופיע‬
‫התו הראשון של המחרוזת ‪.find‬‬
‫‪ ‬ובמשתנה ‪ find‬קיימת המחרוזת "‪ "lom‬לאחר ביצוע הפונקציה‬
‫תוחזר המחרוזת‪“sha” :‬‬
‫תוכנית המדגימה שימוש בפונקציות‬
65
#include <stdio.h>
#include <string.h>
#define SIZE 81
void main()
{
char str1[SIZE]={"Shalom on you "};
char str2[SIZE]={"Shalom on ISRAEL "};
printf("String str1 as: %d chars\n", strlen(str1));
printf("String str2 as: %d chars\n", strlen(str2));
66
printf("String status is: %d\n", strcmp(str1,str2));

printf(“New cat String is: %s\n", strcat(str1,str2));
printf("str1 after cat as: %d chars\n", strlen(str1));
printf("New string is: %s\n", strchr(str1,'o'));
printf("New string is: %s\n", strchr(str2,‘Z'));
printf("New string is: %s\n", strrchr(str2,‘m'));
printf("New string is: %s\n", strstr(str1,"al"));
printf("New string is: %s\n", strstr(str2,"IS"));
67
printf("Old str1 string is: \n", puts(str1));

printf("New string is: %s\n", strcpy(str1,str2));
printf("New str1 string is: \n”);
puts(str1);
printf("New str2 string is: \n”);
puts(str2);
puts(strrev(str1));
puts(strtok(str1,"on"));
}

‫‪68‬‬
‫‪ ‬פונקציית השוואה המחזירה תשובות כמו ‪:strcmp‬‬
‫)] [‪int strcoll (char str1[ ], char str2‬‬
‫‪ ‬ביצוע הפונקציה‪strcoll(str1,str2); :‬‬
‫הפונקציה מחזירה ‪ 0‬אם המחרוזות זהות‪ ,‬כלומר שוות בכל תו עד‬

‫לתו '‪ , '\0‬אחרת מוחזר מס' שונה מ‪ :0-‬חיובי (‪ )1‬אם המחרוזת‬
‫הראשונה גדולה יותר ‪ ,‬לקסיקוגרפית – כלומר לפי סדר מילוני‪ ,‬סדר‬
‫המופיע בטבלת ‪ , ASCII‬ושלילי (‪ )-1‬אם היא קטנה יותר‪.‬‬

‫‪69‬‬
‫‪ ‬פונקציה המעתיקה מחרוזת שניה לראשונה רק מוגבלת בכמות‬

‫תאים להעתקה הנקבעת ע"י המשתנה ‪:num‬‬
‫)‪char strncpy(char str1[ ],char str2[ ],int num‬‬
‫‪ ‬ביצוע הפונקציה‪ strncpy (str1,str2,num); :‬יגרום לכך שלתוך‬
‫המחרוזת ‪ str1‬יועתקו ‪ num‬תווים מהמחרוזת ‪ .str2‬במידה ובתוך‬
‫המחרוזת ‪ tar1‬היו תווים הם נדרסים‪.‬‬
‫‪ ‬לדוגמה‪ :‬במידה ובמחרוזת ‪ str1‬קיים המשפט‪:‬‬
‫ובמחרוזת ‪ str2‬קיימת המילה "‪ "Fm is fine‬ובמשתנה ‪ num‬קיים‬
‫המספר ‪ ,3‬לאחר ביצוע הפונקציה המחרוזת ‪ str1‬תכיל את המחרוזת‪:‬‬
‫"‪"Fm lom dear friend‬‬
‫‪.‬‬
‫‪70‬‬
‫‪ ‬פונקציה המבצעת מילוי מחרוזת בתו מסוים‪:‬‬

‫;)‪char strset(char str[],char ch‬‬
‫‪ ‬ביצוע הפונקציה‪ strset(str,ch); :‬יגרום לכך שהמחרוזת ‪str‬‬
‫תתמלא בתו שנמצא במשתנה ‪.ch‬‬
‫ובמשתנה ‪ ch‬קיים התו ‘@‘ לאחר ביצוע הפונקציה המחרוזת ‪str‬‬
‫תכיל את התווים הבאים‪:‬‬
‫”@@@@@@@@@@@@@@@@@@“‬
‫‪71‬‬
‫‪ ‬פונקציה המבצעת מילוי מחרוזת בתו מסוים ‪ n‬פעמים‪:‬‬

‫;)‪char strnset(char str[],char ch,int num‬‬
‫‪ ‬ביצוע הפונקציה‪ strnset(str,ch,num); :‬יגרום לכך שהמחרוזת‬
‫‪ str‬תתמלא בתו שנמצא במשתנה ‪ ch‬בכמות שיש במשתנה ‪.num‬‬
‫ובמשתנה ‪ ch‬קיים התו ‘@‘ובמשתנה ‪ num‬קיים המספר ‪ , 3‬לאחר‬
‫ביצוע הפונקציה המחרוזת ‪ str1‬תכיל את התווים הבאים‪:‬‬
‫"‪“@@@lom dear friend‬‬
‫‪72‬‬
‫‪ ‬פונקציה המבצעת שרשור ‪ n‬תווים מ‪ str2-‬בסיום ‪:str1‬‬

‫)‪char strncat(char str1[],char str2[],int num‬‬
‫;)‪ strncat(str1,str2,num‬יגרום לכך‬ ‫‪ ‬ביצוע הפונקציה‪:‬‬
‫שמתוך המחרוזת ‪ str2‬ישורשרו תווים בכמות שיש במשתנה‬
‫‪ num‬בסוף המחרוזת ‪.str1‬‬
‫‪ ‬לדוגמה‪ :‬במידה ובמחרוזת ‪ str1‬קיים המשפט‪:‬‬
‫" ‪"shalom dear‬‬
‫ובמחרוזת ‪ str2‬קיימת המילה "‪"friend‬ובמשתנה ‪ num‬קיים ‪,3‬‬
‫לאחר ביצוע הפונקציה המחרוזת ‪ str1‬תכיל את המחרוזת‪:‬‬
‫"‪"shalom dear fri‬‬
73
?‫שאלות‬

74
#include <stdio.h>
#include <string.h>
#define SIZE 81
void main()
{
char str1[SIZE]={“Shalom”};
char str2[SIZE]={“Shlomit”};
char ch='@', ch1='$';
int num=4;

75
printf(“String status is: %d\n”, strcoll (str1, str2));
printf(“New string is: %s\n”, strset(str1,ch));
printf(“New string is: %s\n”, strnset(str1,ch1,num));
printf(“New string is: %s\n”, strncat(str1,str2,num));

‫נקודה לתשומת‪-‬לב‪:‬‬
‫תו בודד ‪ -‬גרש‪ ,‬מחרוזת ‪ -‬גרשיים‬
‫‪76‬‬
‫כדי להתייחס לתו מסוים רושמים אותו בין גרש מימין לגרש‬ ‫‪‬‬
‫משמאל‪ ,‬למשל‪‘a’ :‬‬
‫כדי להתייחס למחרוזת רושמים בתוך גרשיים כפולים‪ ,‬למשל‪:‬‬ ‫‪‬‬
‫”‪“HELLO‬‬
‫אם רושמים ”‪ “a‬המשמעות היא מחרוזת שיש בה את התו ’‪‘a‬‬ ‫‪‬‬
‫ואחריו את התו ’‪ .‘\0‬כלומר זה שונה מאשר לרשום ’‪.‘a‬‬
‫כשעושים פעולות על מחרוזות‪ ,‬משתמשים בפונקציות פנימיות‪,‬‬ ‫‪‬‬
‫יש להקפיד על רישום גרשיים כפולים‪ ,‬למשל‪:‬‬
‫)”‪strcmp(input,”a‬‬
‫ולא‪:‬‬ ‫‪‬‬
‫)’‪strcmp(input,’a‬‬
‫הספריה ‪ ctype.h‬פונקציות על תווים‬
‫‪77‬‬
‫‪ ‬הספריה ‪ ctype.h‬שימושית מאד כאשר מטפלים בתווים בודדים‪.‬‬

‫כל הפונקציות בספריה זו מחזירות מספר שאינו ‪ 0‬אם הבדיקה‬
‫שלהן מחזירה אמת כלומר התשובה לבדיקה חיובית‪.‬‬
‫‪ ‬בכל מקום בו נרשם ‪ ch‬ניתן לרשום גם תו מתוך מחרוזת‪str[i] :‬‬
‫במידה כמובן שהמשתנה ‪ str‬הוגדר כמערך מחרוזתי ‪.char‬‬
‫‪ ‬כל הפונקציות נכתבות בתוכנית ללא הטיפוסים בכחול !!!‬

‫‪ ‬הגדרת פונקציה הבודקת האם במשתנה תווי יש אות קטנה‪:‬‬
‫;)‪int islower(char ch‬‬
‫‪ ‬הגדרת פונקציה הבודקת האם במשתנה תווי יש אות גדולה‪:‬‬
‫;)‪int isupper(char ch‬‬
‫‪78‬‬
‫‪ ‬הגדרת פונקציה הבודקת האם במשתנה תווי יש סיפרה‪:‬‬

‫;)‪int isdigit(char ch‬‬
‫‪ ‬הגדרת פונקציה הבודקת האם במשתנה תווי יש ערך אלפא נומרי‪:‬‬
‫;)‪int isalnum(char ch‬‬
‫‪ ‬הגדרת פונקציה הבודקת האם במשתנה תווי יש ערך אלפא בתי‪:‬‬
‫;)‪int isalpha(char ch‬‬
‫‪ ‬הגדרת פונקציה הבודקת האם במשתנה תווי יש רווח‪:‬‬
‫;)‪int isspace(char ch‬‬
‫‪79‬‬
‫‪ ‬למשל הפונקציות הבאות מבצעות‪:‬‬

‫;)‪char tolower(char ch‬‬ ‫‪ ‬הפיכת אות גדולה לקטנה‬
‫;)‪char toupper(char ch‬‬ ‫‪ ‬הפיכת אות קטנה לגדולה‬
‫‪ ‬אם ‪ tolower‬לא מקבלת אות גדולה אז היא לא משנה אותה‪ ,‬וכך‬
‫גם אם ‪ toupper‬לא מקבלת אות קטנה‪.‬‬
‫‪ ‬זה שימושי כאשר שעובדים עם מחרוזות‪ ,‬שולפים מתוך המחרוזת‬
‫תו ורוצים לבדוק להפוך אותו לאות גדולה או קטנה לפי הצורך‪.‬‬

‫תרגיל כיתה‬
‫‪80‬‬
‫‪ .1‬כתוב תוכנית המגדירה ומבצעת את המשימות הבאות‪:‬‬

‫• תגדיר מערך מחרוזתי בגודל ‪ 30‬מטיפוס ‪ .char‬קלוט לתוכו‬
‫מחרוזת הכוללת אותיות קטנות וגדולות‪ ,‬ספרות ותווים שונים‪.‬‬
‫• תמצא ותציג מה אורך המחרוזת המקורית שנקלטה‪.‬‬
‫• תעתיק את המחרוזת למחרוזת גיבוי‪.‬‬
‫• תמצא כמה אותיות קטנות במחרוזת‪ ,‬תמצא כמה אותיות גדולות‬
‫המחרוזת‪ ,‬תמצא כמה ספרות במחרוזת וכמה תווים שונים‪.‬‬
‫• תחליף את כל האותיות הקטנות לגדולות ואת כל האותיות‬
‫הגדולות לקטנות‪.‬‬
‫• תציג את שתי המחרוזות ‪,‬המקורית והגיבוי‪.‬‬
‫תרגילי כיתה‬
‫‪81‬‬

‫• תגדיר מערך מחרוזתי בגודל ‪ 10‬מטיפוס ‪.char‬‬
‫• תגדיר ותפעיל פונקציה לקליטת ‪ 10‬תווים למערך מחרוזתי‪.‬‬
‫• תגדיר ותפעיל פונקציה הבודקת כי כל התווים במחרוזת הם‬
‫אותיות‪ ,‬רק אם התשובה חיובית נמשיך לשתי הפונקציות‬
‫הבאות‪.‬‬
‫• תגדיר ותפעיל פונקציה למציאת התו הגדול ביותר (על פי טבלת‬
‫האסקי) במערך ולהחזרת ערכו לתוכנית הראשית‪.‬‬
‫• תגדיר ותפעיל פונקציה למציאת התו הקטן ביותר (על פי טבלת‬
‫האסקי) במערך ולהחזרת ערכו לתוכנית הראשית‪.‬‬
‫‪82‬‬
‫‪ .3‬כתוב תוכנית המבצעת את המשימות הבאות‪:‬‬

‫תגדיר שלושה מערכים מחרוזתיים בגודל ‪ 10‬מטיפוס ‪.char‬‬ ‫•‬
‫תגדיר ותפעיל פונקציה לקליטת ‪ 10‬תווים למערך הראשון‪.‬‬ ‫•‬
‫תגדיר ותפעיל פונקציה למציאת כל התווים שהם אותיות‬ ‫•‬
‫גדולות במערך הראשון ותעתיק אותם למערך השני‪.‬‬
‫תגדיר ותפעיל פונקציה למציאת כל התווים שהם אותיות‬ ‫•‬
‫קטנות במערך הראשון ותעתיק אותם למערך השלישי‪.‬‬
‫תגדיר ותפעיל פונקציה המדפיסה את שלושת המערכים לאחר‬ ‫•‬
‫השינויים שנעשו בשתי הפונקציות הקודמות‪.‬‬
‫‪83‬‬
‫‪ .4‬כתוב תוכנית אשר קולטת מחרוזת של תווים מהמשתמש‪,‬‬

‫והופכת אותה‪ ,‬מהסוף להתחלה‪ ,‬ללא שימוש במחרוזת עזר נוספת‪,‬‬
‫כלומר ללא )(‪.strrev‬‬
‫רמז‪ :‬יש להשתמש בשני אינדקסים בלולאה‪ .‬האחד יתחיל מהתו‬
‫הראשון במחרוזת‪ ,‬והשני יתחיל מהתו האחרון‪( .‬נזכור שבתא‬
‫האחרון יש '‪.)'\0‬‬
‫‪ .5‬יש לכתוב תוכנית שתפקידה למחוק רווחים ממחרוזת קלט‪.‬‬
‫התוכנית תבדוק לאחר קליטת תו האם הוא רווח‪ ,‬במידה וכן לא‬
‫תשבץ אותו במערך במידה והוא שונה מרווח תשבצו במערך‪ .‬ניתן‬
‫להניח כי אורך המחרוזת הוא ‪ 15‬תווים בלבד‪.‬‬
‫‪84‬‬
‫‪ .6‬כתוב תוכנית המגדירה ומפעילה פונקציה בשם‪:‬‬

‫‪, strlen_without_ch‬המקבלת מחרוזת תווים‪ ,‬עוברת ובודקת את‬
‫תווים המחרוזת‪ ,‬הפונקציה תספור ותדפיס את מספר התווים‬
‫במחרוזת שאינם האות '‪ 'f‬או ’‪.‘F‬‬
‫‪ .7‬כתוב תוכנית המגדירה ומפעילה פונקציה בשם‪:‬‬

‫‪, strcpy_without_ch‬המעתיקה מחרוזת אחת לשנייה‪ ,‬העתקה‬
‫מתבצעת תו אחרי תו כל עוד התווים המועתקים אינם ’‪ ‘b‬או ’‪.‘B‬‬
‫בסיום תדפיס הפונקציה את המחרוזת החדשה שהתקבלה‪.‬‬

‫מערכים דו ממדים ומחרוזות‬
85
85
.‫נגדיר מערך דו ממדי שיכיל שמות‬

:‫לצורך זה כל שורה במערך תהיה מחרוזת‬
char names[N][STR_SIZE];
G a d i \0
R a m i \0
D a n i \0
#define N 3 ?STR_SIZE -‫ ו‬N ‫מהם הערכים של‬
#define STR_SIZE 5
‫מערכים דו ממדים ומחרוזות – פונקציה למציאת‬
‫מחרוזת במערך דו ממדי‬
‫‪86‬‬
‫‪86‬‬
‫להלן פונקציה המקבלת מילה ומערך‪.‬‬

‫אם השם נמצא במערך הוא יוחלף במילה "*****"‪:‬‬
‫)] [‪void markName(char Names[ ][STR_SIZE],int size, char word‬‬
‫{‬
‫;‪int i‬‬
‫) ‪for ( i = 0; i < size; i++‬‬
‫השוואה בין המחרוזת למילה‪if (strcmp(Names[i],word)==0)//‬‬
‫{‬
‫החלפת המילה שנמצאה ‪strcpy(Names[i],“*****"); //‬‬
‫;‪return 0‬‬
‫}‬
‫}‬
‫מערכים דו ממדים ומחרוזות – פונקציה למציאת‬
‫מחרוזת במערך דו ממדי‬
‫‪87‬‬
‫‪87‬‬
‫להלן פונקציה המקבלת מילה ומערך‪.‬‬

‫אם השם נמצא במערך הוא יסומן ע"י המילה "!!!‪:"Found‬‬
‫)] [‪void markName(char Names[ ][STR_SIZE],int size, char word‬‬
‫{‬
‫;‪int i‬‬
‫) ‪for ( i = 0; i < size; i++‬‬
‫השוואה בין המחרוזת למילה‪if (strcmp(Names[i],word)==0)//‬‬
‫{‬
‫סימון המילה שנמצאה ‪strcat(Names[i],"Found!!!”);//‬‬
‫;‪return 0‬‬
‫}‬
‫}‬
‫תוכנית הכוללת מימוש חיפוש מחרוזת מילה‬
‫במערך דו ממדי נתון‬
88
88
#include <stdio.h>
#include <string.h>
#define ROW 10
#define COL 30
#define WORDSIZE 10
int markName(char Names[][COL], char name[ ])
{
int i;
for ( i = 0; i < ROW; i++ )
if (strcmp(Names[i],name)==0)
strcat(Names[i],“\t<-Found it!!!");
return 0;
}
89
89
int main()
}
int i;
char Names[ROW][COL]={{"Ravit"}, {"Danit"}, {"Rotem"},
{"Daniel"}, {"Galit"}, {"Reot"},
{"Daniela"}, {"Victoria"}, {"Rita"},
{"Gavriela"}};
char name[WORDSIZE]="Reot";
markName(Names,name);
for(i=0; i<ROW;i++)
puts(Names[i]);
{
‫מערכים דו ממדים ומחרוזות – מימוש חיפוש מחרוזת‬
‫במערך דו ממדי‬
90
90
#include <stdio.h>
#define ROW 5
#define COL 6
#define WORDSIZE 4
void main()
}
char matr[ROW][COL]={{'r','v','o','q','w',’\0’},{'a','h','s','x','l',’\0’},
{'n','k','s','d','m’,’\0’}, {'r','a','n','j','r',’\0’}, {'d','k','u','c','a',’\0’}};
char word[WORDSIZE]={‘r’,’a’,’n’,’\0’};
int i,j,k,l;

91
91
//Search for horizontal words (along the columns):
for(i=0; i<ROW; i++) //Scan the rows.
for(j=0; j<=COL-WORDSIZE; j++) //Scan the columns.
{
for(k=j, l=0; l<=WORDSIZE && matr[i][k]==word[l]; k++, l++);
if(l==WORDSIZE-1) //Check if the whole word was encountered.
printf("The word was found horizontally!!! \nIts
coordinates are: i=%d,j=%d,i=%d,j=%d\n", i, WORDSIZE,i,k);
{
92
92
//Search for vertical words (along the columns):
for(i=0; i<COL; i++) //Scan the columns:
for(j=0; j<=ROW-WORDSIZE; j++) //Scan the rows:
}
for(k=j, l=0;l<=WORDSIZE && matr[k][i]==word[l];k++, l++);
if(l==WORDSIZE-1)
printf("The word was found vertically!!! \nIts coordinates are:
i=%d,j=%d,i=%d,j=%d\n", WORDSIZE-k-1,i,k,i);
{
}
‫סיכום‬
‫‪93‬‬
‫הגדרת מחרוזת‪.‬‬ ‫‪‬‬

‫אתחול מחרוזת וסימון סוף מחרוזת‪.‬‬ ‫‪‬‬
‫קלט‪/‬פלט של מחרוזות‪.‬‬ ‫‪‬‬
‫פעולות על מחרוזות‪.‬‬ ‫‪‬‬
‫מציאת אורך מחרוזת‪.‬‬ ‫‪‬‬
‫איתור תו במחרוזת‪.‬‬ ‫‪‬‬
‫פונקציות פנימיות על מחרוזות‪.‬‬ ‫‪‬‬
‫פונקציות פנימיות על תווים‪.‬‬ ‫‪‬‬
‫מערכים דו ממדיים ומחרוזות‪.‬‬ ‫‪‬‬

94
?‫שאלות‬

‫תרגיל כיתה – מחרוזות דו ממד‬
‫‪95‬‬

‫• תגדיר מערך דו ממדי מחרוזתי בגודל ‪ 5X10‬מטיפוס ‪.char‬‬
‫• תקלוט ‪ 5‬מילים בנות ‪ 9‬תווים למערך הדו ממדי ותדפיס אותו‪.‬‬
‫• תקלוט מילה בת ‪ 9‬תווים נוספת למשתנה מחרוזתי נוסף‪.‬‬
‫• תחפש את המילה שנקלטה בנפרד במערך ותציג באיזו שורה‬
‫היא נמצאת במערך‪ ,‬אם המילה לא נמצאת תודפס הודעה‬
‫מתאימה‪.‬‬
‫• במידה והמילה נמצאה במערך יש להחליף אותה באוסף תווי @‬
‫בגודל המילה שהוחלפה‪.‬‬
‫• הדפס את המערך הדו ממדי בסיום העבודה‪.‬‬
‫‪96‬‬

‫תגדיר מערך דו ממדי מחרוזתי בגודל ‪ 10X30‬מטיפוס ‪.char‬‬ ‫•‬
‫תקלוט ‪ 10‬מילים למערך הדו ממדי ותדפיס אותו‪.‬‬ ‫•‬
‫תמצא ותציג מהי המילה הארוכה ביותר שנקלטה למערך ובאיזו‬ ‫•‬
‫שורה היא נמצאת‪.‬‬
‫תחפש האם המילה בשורה הראשונה זהה למילה בשורה‬ ‫•‬
‫החמישית‪.‬‬
‫תשרשר את המילה בשורה שנייה עם המילה שבשורה‬ ‫•‬
‫השלישית ותדפיס את השרשור‪.‬‬
‫‪97‬‬

‫תגדיר מערך דו ממדי מחרוזתי בגודל ‪ 10X20‬מטיפוס ‪.char‬‬ ‫•‬
‫תקלוט ‪ 10‬משפטים למערך הדו ממדי ותדפיס אותו‪.‬‬ ‫•‬
‫תמצא ותציג מהו המשפט שיש בו את מספר האותיות הקטנות‬ ‫•‬
‫הגדול ביותר במערך‪.‬‬
‫תשנה כל משפט בכל שורה כך שהאות הראשונה שלו תהיה אות‬ ‫•‬
‫גדולה וכל שאר האותיות קטנות‪.‬‬
‫תחפש ותציג מהו המשפט במערך שבו מספר האותיות גדול‬ ‫•‬
‫ביותר ללא הרווחים או תווים אחרים במשפט‪.‬‬
‫‪98‬‬

‫• תגדיר מערך דו ממדי מחרוזתי בגודל ‪ 10X20‬מטיפוס ‪.char‬‬
‫• תקלוט ‪ 10‬משפטים למערך הדו ממדי ותדפיס אותו‪.‬‬
‫• תמצא מהו המשפט הארוך ביותר במערך ותחליף אותו במשפט‬
‫‪.Max String‬‬
‫• תמצא מהו המשפט הקצר ביותר במערך ותחליף אותו במשפט‬
‫‪.Min String‬‬
‫• תמצא את המשפט בו יש רק אותיות ותדפיס אותו ואת מיקומו‪.‬‬
‫• תמצא את המשפט בו מספר ספרות מקסימלי ותדפיס את‬
‫מיקומו‪.‬‬
‫‪99‬‬

‫• תגדיר שני מערכים דו ממדים מחרוזתיים בגודל ‪ 5X10‬מטיפוס‬
‫‪ char‬כל אחד‪.‬‬
‫• תקלוט ‪ 5‬משפטים למערך הדו ממדי הראשון ותדפיס אותו‪.‬‬
‫• תקלוט ‪ 5‬משפטים למערך הדו ממדי השני ותדפיס אותו‪.‬‬
‫• תבצע בדיקה של כל מילה מקבילה בין שני המשפטים למציאת‬
‫זהות מוחלטת‪.‬‬
‫• במידה ונמצאה זהות יש לציין כי שתי המילים משני המערכים‬
‫זהות‪ ,‬במידה ולא נמצאה זהות יש לתת הודעה מתאימה‬
‫המציינת באיזו שורה מדובר ובאיזה מילים לא נמצאה הזהות‪.‬‬

פרק 8 - מחרוזות

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

פרק 8 - מחרוזות

Uploaded by

Copyright:

Available Formats

‫קורס יסודות התכנות בשפת ‪C‬‬

‫ד"ר שייקה בילו‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪1‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪ ‬אחרי הגדרת המערך אפשר רק להתייחס לכל תא בנפרד‪.‬‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪#define SIZE 10‬‬ ‫‪ ‬הוגדר גודל מערך‪:‬‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

SCE-Chapter-8-Strings Shayke Bilu PhD

‫‪ ‬נדגים פונקציה שמקבלת מערך של מספרים שלמים ומחזירה את‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

int sumf(int arr[])

SCE-Chapter-8-Strings Shayke Bilu PhD

‫‪ ‬אפשר להגדיר משתני קלט בפונקציה כקבועים (‪.)const‬‬

void printArrayZogi(int a[ ][ COLUMN ])

void printArray(int a[ ][ COLUMN ])

SCE-Chapter-8-Strings Shayke Bilu PhD

‫במקרה זה נתון מערך ממוין שנרצה לחפש בו איבר כלשהו‪.‬‬

‫‪5‬‬ ‫‪8‬‬ ‫‪9 12 15 17 20 21 24 27 29 31‬‬

‫במקרה זה נחפש את הערך ‪ 17‬במערך ע"י חיפוש רגיל‪ ,‬לינארי‪,‬‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

‫נתון מערך ממוין נרצה לחפש בו איבר כלשהו‪.‬‬

‫‪5‬‬ ‫‪8‬‬ ‫‪9 12 15 17 20 21 24 27 29 31‬‬

‫נחפש את ‪ 24‬בחיפוש בינארי בתוך המערך ע"י חלוקת כמות‬

‫‪5‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪12 15 17 20 21 23 24 29 31‬‬

‫נחפש את ‪ 24‬חיפוש בינארי ע"י חלוקת המערך כל חיפוש לחצי‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

?‫שאלות על השעור הקודם‬

SCE-Chapter-8-Strings Shayke Bilu PhD

‫‪ ‬לדוגמא‪ ,‬יש דרך טבעית יותר לאתחל מערך שמייצג מחרוזת‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪ ‬בכל הפקודות והפעולות הקיימות לגבי מחרוזות‪ ,‬יש מוסכמה‬

‫‪ ‬הכנסת התו מאפשרת לבצע פעולות על מחרוזת בלי לדעת‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪ ‬כל הפעולות שנכיר על מחרוזות דואגות בעצמן לשמירת‬

‫’‪‘H’ ‘E’ ‘L’ ‘L’ ‘O’ ‘\0‬‬

‫‪ ‬במידה וקיים ערך של תווים ללא תו סיום‪ ,‬ורוצים להפעיל עליו‬

‫‪ ‬הפונקציה הבאה מקבלת מחרוזת ומחזירה את האורך שלה‪ ,‬בהסתמך על‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

SCE-Chapter-8-Strings Shayke Bilu PhD

‫‪ ‬ניתן לקלוט ולהדפיס את תווי המחרוזת בזה‪-‬אחר‪-‬זה‪ ,‬בעזרת‬

‫;’‪sentence[ i ]=‘\0‬‬ ‫סימון סיום המחרוזת‬

‫‪ ‬אפשר גם לקלוט ולהדפיס מחרוזות בבת‪-‬אחת על ידי שימוש בפונקציות‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

‫כשתוכנס מחרוזת ארוכה יותר מהגודל שהגדרנו למערך‪ ,‬התוכנית‬ ‫‪‬‬

‫‪ ‬הפקודה הבאה תדפיס את תווי המחרוזת ‪ answer‬עד לתו '‪.'\0‬‬

‫‪ ‬פקודת קלט נוספת למחרוזות שקולטת מחרוזת תווים כולל רווח‪:‬‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪ ‬פקודת פלט תואמת המבצעת הדפסה וירידת שורה‪:‬‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

‫קלט תו‪-‬תו בלולאה‬ ‫•‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

SCE-Chapter-8-Strings Shayke Bilu PhD

‫‪ ‬לא ניתן לבצע פעולות השוואה והשמה על מחרוזת שלמה‪:‬‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

‫לביצוע פעולות על מחרוזת שלמה יש צורך להשתמש בפונקציות‬ ‫‪‬‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪ ‬פונקציה המבצעת הפיכה של מחרוזת למספר שלם‪:‬‬

‫‪ ‬פונקציה המבצעת הפיכה של תווי המחרוזת לאותיות גדולות‪:‬‬

‫;)] [‪void strupr(char str‬‬

‫‪ ‬ביצוע הפונקציה‪ strupr(str); :‬יגרום לכך שבתוך המחרוזת ‪str‬‬

‫‪ ‬לדוגמה‪ :‬במידה ובמחרוזת ‪ str‬קיים המשפט‪"shalom friend" :‬‬

‫‪SCE-Chapter-8-Strings‬‬ ‫‪Shayke Bilu PhD‬‬