מצ"ב תרגיל שאני אפתור, אבל... לא הבנתי האם הכוונה שאני מטפל במס' מספרים שיהיו כל פעם סט מספרי אחר, כלומר כל הפעלת תוכנית יהיה רצף אחר של מספרים ? כי אז אני יכול להשתמש ב- EOF... ולמה הכוונה לעזאזל ב"ארגומנטים" ?!

תודה !!

[attachment deleted by admin]

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

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

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

אז אם נניח אני מתחיל כך:

int smallest(int num, ...)
{
 va_list argreceived;
}

אז הפונקציה שלי כרגע יודעת לקבל רשימת ארגומנטים בגודל כלשהו כאשר כל ארגומנט הוא בגודל int, כאשר הפקודה הראשונה בפונק' תהיה:

 va_list argreceived;

ע"מ להכניס את הרשימה שהפונקציה מקבלת לתוך פרמטר בשם argreceived ?

לאחר מכן אני יודע לעבור איבר איבר ע"י va_arg וכך לבצע את המשימה שהוטלה עלי ? או שאני מפספס משהו ?

כן, משהו כזה.

שים לב שצריך גם va_start בהתחלה ו-va_end בסוף.

למה אני מאתחל את הרשימה ומנקה אותה בסוף ?

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

ה-va_start נחוץ כי ה-va_list רק מצהיר על הרשימה, לא מאתחל אותה.

לא יודע אם ה-va_end נחוץ, אבל בכל הדוגמאות משתמשים בו גם כן, אז מומלץ.

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

אבל יש לי בעיה עקרונית עם האלגוריתם, כי אומרים שהיא מחזירה את המס' הקטן ביותר שנשלח עד כה! הבעיה שהפרמטר שאני אגדיר בה לזכירת המס' הכי קטן ימות ברגע שהפעולה אליה תסתיים. כלומר אני תמיד יכול להכניס בתוכנית הראשית "תוספת" לזיכרון המס' הקטן ביותר אבל הכוונה היתה לעשות את זה בפונק' :'( (תקן אותי אם אני טועה), ואין לי רעיון לאלגוריתם שיגרום לפונק' לזכור משהו בתוכה אחרי שהיא הסתיימה....

על static שמעת?

צודק....

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

בדיוק.

יש משהו שמטריד אותי ...

אם רשום שכל רשימה מסתיימת ב- 1- מה זה נותן לי המידע הזה ? :s05: הרי בסה"כ אני יכול לדעת שהגעתי לסוף הרשימה בדרך אחרת גם לא ?!

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

סבבה... אז ניסיתי לעשות כך:

#include <stdarg.h>
#include <stdio.h>

int small(int num, ...)
{
 va_list argreceived;
 va_start(argreceived, num);

 static int smallest=0; //smallest number

 while (va_arg(argreceived , int)!=-1)
 {
	 if ( va_arg(argreceived , int) < [va_arg(argreceived , int)]-1 )  //weird line
		 smallest = va_arg(argreceived , int);
	 else smallest = [va_arg(argreceived , int)]-1 


 }
 va_end(argreceived); //clean list
 return (smallest);

}

int main()
{

	small(10 , 20, 210, 3 , 4 , -1);
  small(1 , 2 , 4 , -1); // should return the value 1 after this order
return (0);
}

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

אשמח אם תאיר ותעיר

תודה

שים לב שכל פעם שאתה עושה va_arg אז זה ניגש לארגומנט הבא. הבעיה היא שכשאתה עושה va_arg ארבע פעמים בכל איטרציה, אז בכל איטרציה אתה קורא ארבעה ארגומנטים!

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

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

אז איך אני ניגש לארגומנט הנוכחי? :-\ יש שיטה כמו כמערך לפנות לקודם של הבא או יותר פשוט לאיבר הראשון וכל פעם להתקדם ע"י va_arg?

ומבחינת לולאת ה- while, אין צורך מבחינת האלגוריתם להוסיף או להחליף אותה בלולאת for נכון ?