הפונקציה הסטנדרטית של ספריית C המשמשת לשרשור מחרוזת היא strcat ().
אב טיפוס פונקציה:
$לְהַשְׁחִיר * strcat (str1,str2);כאשר str1 הוא המחרוזת הראשונה ו- str2 היא המחרוזת השנייה. ערך ההחזרה של הפונקציה הוא המצביע למחרוזת המחוברת.
כעת, בעזרת הדוגמה נראה כיצד מבוצע השרשור.
דוגמה 1:
$ strcat (str1,str2);כאשר str1 היא בלה
str2 הוא ויטמן
לאחר שרשור המחרוזת,המחרוזת הראשונה תהיה
str1 בלה ויטמן
str2 ויטמן
בעוד מחרוזת 2 תישאר זהה.
דוגמה 2:
$ strcat (str2,str1);כאשר str1 היא בלה
str2 הוא ויטמן
לאחר שרשור המחרוזת,מחרוזת מחוברת תהיה
str1 בלה
str2 בלה ויטמן
בעוד מחרוזת 1 תישאר זהה.
הצהרה בקובץ כותרת C
פונקציות טיפול במחרוזות מוכרזות תחת קובץ כותרת עליונה. אם רוצים להשתמש בפונקציה סטנדרטית כדי לחבר, יש לכלול קובץ כותרת זה.
מכאן שנוכל להשיג שרשור מחרוזות בשתי דרכים. אחת מהן היא שימוש בפונקציית הספרייה Standard C והשנייה היא ללא שימוש בפונקציית ספריית C. להלן תוכניות לדוגמא להדגמת שתי הדרכים. ניתן ליישם שרשור מחרוזות ללא שימוש בפונקציית ספריית C במספר דרכים.
נדון גם בזה בחלקים הבאים עם דוגמה.
חיבור של שני מחרוזות באמצעות פונקציית ספריית C
#לִכלוֹל#לִכלוֹל
#הגדר BUF_SIZE 256
intרָאשִׁי()
{
לְהַשְׁחִירS1[BUF_SIZE],S2[BUF_SIZE]; / * שני חוצצי מחרוזות */
printf ('הזן את המחרוזת הראשונה n'); ] /* הדפס הודעה למסוף כדי שהמשתמש יזין מחרוזת 1*/
fgets (S1,BUF_SIZE,stdin); / * אחסן את מחרוזת קלט המשתמש במאגר S1 */
S1[ strlen (S1)-1] = ' 0';
printf ('הזן את המחרוזת השנייה n');/* הדפס הודעה למשתמש כדי להזין מחרוזת 2*/
fgets (S2,BUF_SIZE,stdin); / * אחסן את מחרוזת קלט המשתמש במאגר S2 */
S2[ strlen (S2)-1] = ' 0';
strcat (S1,S2); / *התקשר לפונקציה הסטנדרטית עם מחרוזות S1 ו- S2 */
printf (' nמחרוזת מחוברת היא %s n n',S1); / *פלט: S1 מצורף עם S2 */
לַחֲזוֹר 0;
}
תמונות של התוכנית והפלט:
חיבור של שני מחרוזות ללא שימוש בפונקציית הספרייה
שימוש עבור לולאה להעתיק את המחרוזת השנייה בסוף המחרוזת הראשונה.
#לִכלוֹל#לִכלוֹל
#הגדר BUF_SIZE 256
intרָאשִׁי()
{
לְהַשְׁחִירS1[BUF_SIZE],S2[BUF_SIZE]; /* הצהרת המאגרים S1, S2 לשני המחרוזות*/
intאורך= 0,אני,י; /*משתנים הדרושים לחציית לולאה*/
printf ('הזן את המחרוזת הראשונה'); / * הדפס הודעת משתמש כדי להזין מחרוזת ראשונה */
fgets (S1,BUF_SIZE,stdin); /* מחרוזת קלט המשתמש תשמור ב- S1*/
S1[ strlen (S1)-1] = ' 0';
printf ('הזן את המחרוזת השנייה'); / * הדפס הודעת משתמש כדי להזין מחרוזת שנייה */
fgets (S2,BUF_SIZE,stdin); /* מחרוזת קלט של משתמשים תישמר ב- S2*/
S2[ strlen (S2)-1] = ' 0';
/* חצו את המחרוזת הראשונה כדי למצוא את אורך S1*/
ל(אני=0;S1[אני]! =' 0';אני++)
{
אורך=אורך+1;
}
/*אורך יהיה סוף ה- S1, התחל מאורך והעתק את כל S2 ל- S1*/
ל(אני=אורך,י=0;S2[י]! =' 0';אני++,י++)
{
S1[אני]=S2[י];
S1[אני]=' 0';
}
/ *הדפס את התוצאה S1, המשולבת */
printf (' nמחרוזת מחוברת היא %s n n',S1);
לַחֲזוֹר 0;
}
תמונות של התוכנית והפלט:
עוד דרך ללא פונקציית ספרייה
חיבור באמצעות רקורסיה:
הפונקציה stringconcatenate () תשמש כדי לקבל את אורך המחרוזת 1. אם S2 ריק אז תוענק ל- S2 תו null.
אם לא מוקצה תו null ל- S2 מאשר להוסיף רכיב של S2 בסוף S1 כלומר S1 [i+j] = S2 [j], הדבר מגדיל את הערך של i במחרוזת.
פונקציה תקרא לעצמה על ידי העברת המיתרים המתוקנים (S1, S2) כטיעון. הוא ייקרא שוב ושוב עד שה- S2 ריק.
ה- S1 המחובר יודפס על ידי main () as
#לִכלוֹל#לִכלוֹל
#הגדר BUF_SIZE 256
/ * פונקציה רקורסיבית ליישום שרשור מחרוזות בהתאם לתיאור לעיל */
בָּטֵלמחרוזת מחברים(לְהַשְׁחִיר *S1,לְהַשְׁחִיר *S2)
{
סטָטִי intאני=0;
סטָטִי intי;
י= strlen (S1);
אם(!S2[אני])
{
S2[אני]=' 0';
}
אַחֵר
{
S1[י] =S2[אני];
S1[י+1] = ' 0';
אני++;
מחרוזת מחברים(S1,S2);
}
}
intרָאשִׁי()
{
לְהַשְׁחִירS1[BUF_SIZE],S2[BUF_SIZE];
printf ('הזן את הערך של המחרוזת הראשונה:'); / * הודעת משתמש כדי להזין מחרוזת ראשונה */
fgets (S1,BUF_SIZE,stdin); / * קלט משתמש מחרוזת ראשונה, אחסן ב- S1 */
S1[ strlen (S1)-1] = ' 0';
printf ('הזן את הערך של המחרוזת השנייה:'); / * הודעת משתמש לקלט מחרוזת 2 */
fgets (S2,BUF_SIZE,stdin); / * קלט משתמש מחרוזת ראשונה, אחסן ב- S2 */
S2[ strlen (S2)-1] = ' 0';
מחרוזת מחברים(S1,S2); / * קראו לפונקציה עם S1, S2 כפרמטרים */
printf ('שילוב מחרוזות ='%s ' n',S1);
לַחֲזוֹר 0;
}
תצלומי התוכנית והפלט:
שרשור באמצעות שימוש בפונקציות
הפונקציה strconcatenate () נקראת על ידי הראשי () לשלב שתי מחרוזות.
הפונקציה מקבלת את אורך המחרוזת 1 באמצעות stringlen (string1).
צמוד למרכיבי מחרוזת 2 [i] במחרוזת 1 [i+j]. שלב זה יחזור על עצמו עד שהמחרוזת ריקה. כאן, אנו מתחברים למחרוזת 2 למחרוזת 1 בסוף מחרוזת 1.
מחרוזת מחוברת (מחרוזת 1) תתקבל עד הסוף כאשר כל האיטרציות של הלולאה יבוצעו.
הראשי () מדפיס את המחרוזת המחוברת S1
#לִכלוֹל#לִכלוֹל
#הגדר BUF_SIZE 256
/ * פונקציה ליישום שרשור מחרוזות בהתאם לתיאור לעיל */
בָּטֵלstrconcatenate(לְהַשְׁחִיר *מחרוזת 1, לְהַשְׁחִיר*מחרוזת 2)
{
intאני;
intי= strlen (מחרוזת 1);
ל(אני=0;חוּט2[אני];אני++)
{
מחרוזת 1[אני+י]=מחרוזת 2[אני];
}
מחרוזת 1[אני+י]= ' 0';
}
intרָאשִׁי()
{
לְהַשְׁחִירמחרוזת 1[BUF_SIZE],מחרוזת 2[BUF_SIZE];
printf ('הזן את המחרוזת הראשונה:'); / * הודעת משתמש למחרוזת ראשונה */
fgets (מחרוזת 1,BUF_SIZE,stdin); / * קלט משתמש מחרוזת שנייה, מאוחסנת במחרוזת 1 */
מחרוזת 1[ strlen (מחרוזת 1)-1] = ' 0';
printf ('הזן את המחרוזת השנייה:'); / * הודעת משתמש למחרוזת 2 */
fgets (מחרוזת 2,BUF_SIZE,stdin); / * קלט משתמש מחרוזת שנייה, מאוחסנת במחרוזת 2 */
מחרוזת 2[ strlen (מחרוזת 2)-1] = ' 0';
strconcatenate(מחרוזת 1,מחרוזת 2); /* קראו לפונקציה עם string1 ו- string2 כארגומנטים*/
printf ('מחרוזת שנוצרה = %s' n',מחרוזת 1);
לַחֲזוֹר 0;
}
תמונות של התוכנית והפלט:
שרשור מחרוזת באמצעות memcpy
באמצעות הפונקציה memcpy (), שרשור המחרוזת מתבצע על ידי העתקת מילה במילה ממאגר מחרוזות אחד עד לסוף מאגר מחרוזות אחר שבו גודל המילה הוא 4 בייטים בהתחשב בכך שאנו פועלים במחשב 32 ביט בעוד שאנו מבצעים שרשור מחרוזות על ידי באמצעות שרשור מחרוזות באמצעות הפונקציה strcat (), השילוב מתבצע על ידי העתקת בתים בתים ממאגר מחרוזות אחד למאגר מחרוזות אחר.
גישה זו יעילה בביצועים.
השיקול היחיד בעת השימוש ב- memcpy הוא לדאוג ל' 0 '.
תוכנית C להשגת strcat עם memcpy:
#לִכלוֹל#לִכלוֹל
#הגדר BUF_SIZE 256
בטל strcat_memcpy(לְהַשְׁחִיר *S1, לְהַשְׁחִיר *S2)
{
intאורך 1,אורך 2;
אורך 1= strlen (S1);
אורך 2= strlen (S2);
memcpy (S1+אורך 1,S2,אורך 2);
}
intרָאשִׁי()
{
לְהַשְׁחִירמחרוזת 1[BUF_SIZE],מחרוזת 2[BUF_SIZE];
printf ('הזן את המחרוזת הראשונה:'); / * הודעת משתמש למחרוזת ראשונה */
fgets (מחרוזת 1,BUF_SIZE,stdin); / * קלט משתמש מחרוזת שנייה, מאוחסנת במחרוזת 1 */
מחרוזת 1[ strlen (מחרוזת 1)-1] = ' 0';
printf ('הזן את המחרוזת השנייה:'); / * הודעת משתמש למחרוזת 2 */
fgets (מחרוזת 2,BUF_SIZE,stdin); / * קלט משתמש מחרוזת שנייה, מאוחסנת במחרוזת 2 */
מחרוזת 2[ strlen (מחרוזת 2)-1] = ' 0';
strcat_memcpy(מחרוזת 1,מחרוזת 2); /* קראו לפונקציה עם string1 ו- string2 כארגומנטים*/
printf ('מחרוזת שנוצרה = %s' n',מחרוזת 1);
לַחֲזוֹר 0;
}
תמונות של התוכנית והפלט:
סיכום:
עם כל הדיון הזה נוכל לסכם את שרשור המחרוזות ב- C. ראינו דוגמאות רבות ותוכניות לדוגמא לשילוב מחרוזות. נזכור את הפריטים העיקריים: ישנן שתי דרכים, אחת עם תקן C והאחרת היא דרך המוגדרת על ידי המשתמש. משתמש מוגדר יכול להיות גם מסוגים רבים, תלוי באופן שבו המשתמש רוצה ליישם שרשור מחרוזות.