איפוס מערך ב-C

[white shadow 3]

איפוס מערך ב-C

הי.
נניח שיש לי פונקציה שמקבלת כפרמטר פוינטר למערך (char), שאני לא יודע מה גודלו או האם יש בו גרגע איברים כלשהם או לא.
האם ישנה איזשהיא פונקציה ב-c שדורסת לי הכל ומביאה אותי למצב
zz a[0]="\0" zz
(אני לא רוצה להגיע למצב שבו כל האיברים שם ממש 0 כי בסוף הפונקציה חוזרים לפונקציה שקראה לה ומדפיסים את איברי המערך (אין לי שליטה על הפונקציה שקראה לפונקציה הזאת) לכן אני רוצה שיהיו במערך רק איברים שאני הכנסתי דרך הפונקציה שלי..

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

תודה!

 

[BravoMan]

לא ברור לחלוטין מה אתה רוצה:

בשפת C, אם נתנו לך רק מצביע למערך בלי פרמטר נוסף של גודל, אתה לא יכול לדעת מה גודל המערך, ולכן אתה גם לא יכול לאפס את כל האיברים בו בצורה בטוחה.
&nbsp
אם אתה רוצה לאפס רק את האיבר הראשון, הרי שאין בעיה. בהנחה שמדובר במצביע חוקי לזיכרון ששיך לך, אפשר להניח שלפחות תא אחד שם הוא "שלך", ואז הצבה פשוטה כפי שכתבת תעבוד רגיל.
&nbsp
רק שים לב שכשאתה כותב "0\" בגרשיים כפולות אתה מקבל מחרוזת בעורך 2 תווים, ששניהם תו 0!

 

[white shadow 3]

ראיתי באחד האתרים

שאם יש לי מערך char ואני כותב
zz char[0]='\0' zz
הוא מאפס / מאתחל / (לא ממש יודע איך לקרוא לזה..) את המערך
כלומר אם המערך קודם היה
zz 2,3,5, \0 zz
ואני כתוב
zz printf("%s\n",a) zz
אז יודפס לי
5 3 2
אבל אם אכתוב לאחר מכן:
char[0]='\0' zz
ואנסה להדפיס
zz printf("%s\n",a) zz
אז הוא לא ידפיס כלום על המסך
&nbsp
אני לא בטוח 100% מה קורה מאחורי הקלעים והאם הפעולה הזאת חוקית..
&nbsp

 

[BravoMan]

לא מאפס, ולא מאתחל!

זה א' - ב' של עבודה עם מחרוזות בשפת C:
תו 0 - תו שערכו 0 (לא זה שמדפיס את הספרה 0 למסך! לא להתבלבל בניהם!) נחשב "תו נועל" מבחינת כל פונקציה סטנדרטית שמטפלת במחרוזות.
&nbsp
בגלל שגם printf לא יודעת מה אורך המערך שנתת לה, היא מדפיסה את כל התאים עד שהיא נתקלת בתא שיש בתוכו 0.
&nbsp
שים לב להבדל חשוב: כשאתה כותב תו אחד בין גרש בודד, למשל 'A' הקומפיילר באמת מפרש את זה כתו בודד.
אבל, אם אתה משתמש בגרשיים, ככה "A" הקומפיילר מפרש את זה כמחרוזת, ומוסיף בשבילך אוטומטית תו נועל. לכן, למרות שיש רק אות אחת בין הגרשיים, למעשה המחרוזת תופסת 2 תאים מסוג char בזיכרון!

 

[white shadow 3]

יכול להיות שלא הבנתי משהו או שלא הובנתי כראוי

(או שאולי אני חושב מתייחס ל-2 דברים כשונים אבל בעצם מדובר באותו דבר)
התכוונתי למעלה לתו ה"סגירה"
0\
של המערך ולא לתו 0 עצמו.
אז - מה בפועל קורה אם אני מקבל פוינטר לתחילת מערך a כלשהוא, ובשורה הראשונה של הפונקציה שלי אני כותב
a[0]='\0';

זה לא עושה סוג של "RESET" (לא בטוח אם זאת 100% המילה הנכונה שאני מחפש..) למה שהיה עד כה במערך שקיבלתי?

 

[BravoMan]

אין דבר כזה "תו נועל מערך".

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

שורת הקוד שנתת מציבה את הערך המספרי 0 בתא הראשון של המערך שנקרא a. רושמת 0 למקום מסוים בזיכרון.

אין הבדל בין הצבה כזו להצבה של כל מספר אחר, למשל, אותו דבר היה קורה אם היית כותב:
a[0] = 10;
רק שבמקום 0 היה נכתב 10 לאותו מקום בזיכרון.

בגלל שזיכרון המחשב יכול לשמור רק מספרים (למעשה ייצוג של מספרים) ולא אותיות, בחרו לייצג אותיות ע"י מספרים, אז כשאתה כותב:
a[0] = 'A';

אתה למעשה מציב מספר 65 בתוך התא הראשון במערך.
השורה הזו זהה:
a[0] = 65;

אז, מה מיוחד ב-0?
שום דבר! אין שום reset, אין שום שחרור זיכרון, כלום! זו רק הצבה של מספר, אין שום הבדל בינה לבין הצבה של כל מספר אחר!

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

כמו שאתה בתור בן אדם יודע שסיימת לקרוא משפט כשאתה נתקל בנקודה, כך הפונקציה printf יודעת שהיא סיימה לטפל בטקסט שיש להדפיס כשהיא רואה תא במערך שיש בתוכו 0.

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

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