זה כבר הפעם השנייה שאני נתקע עם אותה בעיה.

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

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

בתודה מראש.

תנסה להשתמש בדגל ( מסוג גלובאלי ) בתחילת הפונקציה עם משפט IF .

עם סתם משתנים גלובאלים.

איזו טעות כתיב נוראית הייתה לי!!!!

משתנים גלובאלים בהחלט יוכלו לעזור .

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

טוב אולי זה יהיה יותר יפה אני יראה כבר ויבחר אחד משני השיטות.

תודה רבה לשניכם רעיונות נוספים יתקבלו בברכה.

אם המשתנים האלה הם קבועים, תגדיר אותם ככאלה.

אם הם קשורים לאלגוריתם, הגיוני שהם יהיו פרמטרים של הפונקציה.

אם מעצבן אותך פונקציה עם הרבה פרמטרים, תגדיר אותם בתוך struct ותעביר אותו.

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

אתה כותב ב-C?

אם כן, בדיוק בשביל זה נועדה המילה static.

הגדרת משתנה כ-static אומרת שהמשתנה יחיד עבור כל הקריאות לפונקציה, כלומר הערך שלו יישמר בין קריאה לקריאה לפונקציה (אבל תוכל לגשת אליו רק מתוך הפונקציה, ולא מבחוץ).

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

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

ואפשרות שלישית זה לכתוב ב-C++, שם אתה יכול פשוט לשים את המשתנים האלה כאיברים פרטיים של איזשהו קלאס שהפונקציה תשכון בו.

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

אבל אני יתן לכם בעיה דומה שהייתה לי ....

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

במקום לבלבל אתכם החלטתי להעתיק לכתוב את זה למחשב.

turnlist(h,h)

void turnlist(struct item *hdptr,struct item *begin)

{

if (hdptr!=NULL && hdptr->next!=NULL)

turnlist(hdptr->next,begin);

if (hdptr!=NULL && hdptr!=begin && hdptr->next!=begin)

{

change(&hdptr->phone,&begin->phone);

begin=begin->next;

}

}

השורה הראשונה היא הקריאה לפונקציה.

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

מה זה BEGIN מה זה CHANGE ולמה אתה מקדם את BEGIN אחריו? אולי רצית לעשות שם מצביע למצביע?

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

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

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

הפונ לא תעבוד לך. תגדיר את BEGIN כמצביע למצביע.

אין לי עניין בשינוי begin מחוץ לפונקצייה אלא רק שינוי הערכים שעליהם הוא מצביע ולכן אני לא צריך לשלוח מצביע למצביע.

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

אני מקווה שאני מובן.

אז הוא לא ישנה לך את הBEGIN בכלל ואתה כל הזמן תחליף את אותו איבר.

אוקיי טעיתי אז אני שולח את begin לפונקצייה ** ומוסיף למטה בהשמה *.

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

לא ממש הבנתי את התכנית שלך, אבל הבנתי את הבעיה שלך. להלן פתרון אלגנטי :

נניח שם הפונקציה הרקורסיבית הוא A והערכים ההתחלתיים הם x,y,z אזי, ניצור פונקציית עזר B והיא תהיה הרקורסיבית, כלומר מתוך A נקרא לB.

קוד להמחשה -

int A(int x, int y, int z)

{

do somethig with x,y,z

B(x,y,z)

}

int B(int x, int y, int z)

{

if (recursive condition) return 1

else

B(x',y',z')

}

כאשר x',y',z' הם x,y,z ששונו... ברור שתכנית זו לא עושה כלום מלבד להחזיר 1, אבל הרעיון אמור להיות ברור.

מטי.