איך אני שולח מערך תלת מימדי לפונקצייה ואיך נראית שורת ההגדרה בפונקצייה .

באישה שפה??

C++?

type ***name, int *size

טוב כמו שעשיתי לבסוף.

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

האם זאת הדרך היחידה?????

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

עריכה: שפת C.

אם אתה יודע מראש את גודל המערכים, אז אפשר באמצעות סוגריים מרובעים:

int[10][20][30]

שים לב שאם הגדרת את המערך ככה אבל אתה מעביר אותו כ-int*** זה יכול לעשות בעיות (הקומפיילר לא יידע את הגודל של המערך כשאתה בתוך הפונקציה).

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

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

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

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

שאלה נוספת היא אם אני רוצה לשלוח חלק מהמערך לדוגמא רק את המימד הפנימי של המערך כיצד אני מבצע זאת בקריאה לפונקצייה ובהצהרה??? לפי מה שאני חושב בקריאה לפונקציה a[x][y] b

ובקבלה לפונקצייה או a* או a[x] b ואם התשובה לשאלה הראשונה שלי תהיה חיובית אז יש דרך שלישית עם סוגריים ריקות.

* אל תתיחסו לאות b היא נועדה למנוע בעיות של צרוף אנגלית בטקסט עברי.

אני ככל הנראה יריץ את התוכנה על מהדר tclite האם הוא טוב???????

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

הנה ההסבר למה:

כשאני מגדיר מערך מהצורה int a[10][20][30], המערך a מוגדר בעצם כרצף של 10*20*30 אינטים בזכרון.

אפשר בעצם להתייחס אל המערך התלת-מימדי כרצף של 10 מערכים דו-מימדיים בגודל 20*30, שיושבים בזכרון זה אחר זה.

ובעצם כל מערך דו מימדי כזה הוא רצף של 20 מערכים ממימד אחד, באורך 30.

כשאני ניגש ל-[a[x, הוא רוצה לחפש את תת המערך הדו-מימדי שיושב במקום x. איך הוא עושה את זה? ניגש למקום שבו יושב המערך בזכרון, ומדלג x גדלים של התת-מערך הדו-מימדי קדימה, כלומר x*30*20 צעדים. שם יושב בדיוק התת-מערך [a[x.

בשביל לעשות את זה, הוא חייב לדעת את הגודל של תת המערך (כלומר ה-20 וה-30).

מובן?

הגודל של המערך כולו (10) לא קריטי בשביל הקומפיילר (אבל חשוב לדעת אותו כדי למנוע גלישות).

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

הנה ההסבר למה:

כשאני מגדיר מערך מהצורה int a[10][20][30], המערך a מוגדר בעצם כרצף של 10*20*30 אינטים בזכרון.

אפשר בעצם להתייחס אל המערך התלת-מימדי כרצף של 10 מערכים דו-מימדיים בגודל 20*30, שיושבים בזכרון זה אחר זה.

ובעצם כל מערך דו מימדי כזה הוא רצף של 20 מערכים ממימד אחד, באורך 30.

כשאני ניגש ל-[a[x, הוא רוצה לחפש את תת המערך הדו-מימדי שיושב במקום x. איך הוא עושה את זה? ניגש למקום שבו יושב המערך בזכרון, ומדלג x גדלים של התת-מערך הדו-מימדי קדימה, כלומר x*30*20 צעדים. שם יושב בדיוק התת-מערך [a[x.

בשביל לעשות את זה, הוא חייב לדעת את הגודל של תת המערך (כלומר ה-20 וה-30).

מובן?

הגודל של המערך כולו (10) לא קריטי בשביל הקומפיילר (אבל חשוב לדעת אותו כדי למנוע גלישות).

אוווווווווווווווו סוף סוף הסבר שמניח את דעתי באשר לשליחה לפונקצייה תודה רבה מאיפה אתה משיג את המידע הזה??????

יפה עכשיו בהמשך למה שאמרת בקשר לשליחה לפונקצייה איך אני יכול לשלוח את שם המערך הרי לא ידוע הגודל של המערך????

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

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

מאיפה אתה משיג את המידע הזה??????

יש לי מקורות משלי

האמת היא שאני יחסית פחות מכיר את ההתנהגות של מערכים רב מימדיים (אני גם לא ממש מת על הנושא, הוא די מגעיל). אני אישית מעדיף להשתמש ב-vectorים, הם די פותרים לך את רוב הבעיות.

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

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

להעביר מערך (במיוחד כשמדובר במערך גדול) על גבי ה- stack זה בזבוז נוראי וגם מסוכן (ענייני buffer overflow), עדיף להעביר מצביע למערך.

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

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

אבל אני רוצה לדעת איך המחשב יודע אם אני מעביר מצביע מה להעביר בדיוק לפי ההסבר הקודם של שניצל??????

האמת, זה בדיוק מה שהוא כתב. (אם לא הייתי מתעצל קודם לקרוא את כל מה הוא כתב לא הייתי מוסיף תגובה)

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

אכפת לו רק אם הפונקציה לוקחת מצביע, או מערך (ואם אתה מעביר את הסוג הלא נכון, הקומפיילר יצעק עליך על חוסר התאמה בטיפוסים)

כשאתה מעביר מצביע, אתה מעביר משתנה שמכיל כתובת (במקרה של מצביע למערך - זאת הכתובת שבו נמצא האיבר הראשון של המערך, כלומר ב- stack נמצא רק המשתנה שמכיל את הכתובת).

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

אני לא חושב שאתה צודק.

כשאתה מעביר מערך ב-C אתה מעביר אך ורק את המצביע למערך, ולא מעתיק אותו ל-stack.

אך ורק structים (וקלאסים ב-C++) מועתקים ל-stack.

הנה, מתוך האתר הזה:

http://www.themost.org/courses/langs/eoc/lessons/eoc_06.html

When an array is passed to a function, only the address is passed, not the entire array. When a function is called with just the array name, a pointer to the array is passed. (In C, an array name without an index is a pointer to the first element.) This means that the parameter declaration must be of a compatible pointer type.

לפי ההסבר החדש של boomerang +ההסבר הראשון של שניצל הכל מובן פיקס.....

ויש לכם מושג איפה אפשר לקרוא על איך המחשב מבצע את כל הפעולות האלו(כל מיני דברים שכגון זה) מעבר לפעולות הטכניות שאני צריך לבצע בשביל עבודת התוכנית???