כן אני עובד בדוס.

ואני אשמח אם תוכל לשלוח לי את bc31, אני מחפש את זה כבר שבועיים.

myfake@walla.co.il

הTC3 פשוט לא מכיר את כל הפונקציות שהשתמשת. הוא תומך במשהו שנקרא BIDS.

הוא גם לא מכיר את הinclude בלי ה.h.

הBC31 תומך בSTL?

אני לא בטוח, יש לי Builder 5 חוקי.

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

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

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

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

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

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

אם יש לך זמן (וכוח), תוכל אולי להסתכל בעזרה של הBC31 ולראות אם אתה מבין איך משתמשים בזה.

אם אני זוכר נכון, הBC31 משתמש באותן ספריות כמו הTC3 שיש לי.

אם זה אותו דבר, אז אתה פשוט צריך ללחוץ כפתור ימני בקוד, ואז לחפש list/doublelist באינדקס.

אם יש לך זמן (וכוח), תוכל אולי להסתכל בעזרה של הBC31 ולראות אם אתה מבין איך משתמשים בזה.

אם אני זוכר נכון, הBC31 משתמש באותן ספריות כמו הTC3 שיש לי.

הסתכלתי והקוד שנתתי לא יעבוד גם ב BC31. (התמיכה ב STL לא מלאה)

אולי כדאי לך לנסות סביבה חינמית כלשהיא. אגב, הסתכלת על הקוד של MAME32 ?

כבר כתבתי לבד מחלקה ופונקציות לרשימה דו כיוונית. ;D

בינתיים (אני מפעיל את זה בנפרד מהסנייק), זה עובד יפה מאוד.

אני רק מכניס כמה שיפורים.

עשיתי חפיפת אופרטורים ל[] ככה שאם s היא רשימה מקושרת, אז [s[5 יחזיר מחוון לאיבר החמישי ברשימה.

כל איבר הוא מבנה מסוג XY (דומה לpoint שנתת לי).

עכשיו ניסיתי לחפוף גם את ==, ככה שאם עושים:

if(s[ 0 ]==s[ 1 ])

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

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

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

אני יכול לחפוף אותו כגלובלי, אבל אז זה ישפיע על כל הפעולות.

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

אולי לעשות משהו עם ערך התייחסות?

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

בכל מקרה, אני כבר מעדיף לתכנת הכל בעצמי.

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

יש לי שאלה בכל זאת - יש אפשרות לעשות את הדבר הבא?:

if(s[ 0 ]==s [ 5 ] )

if(s[ 0 ]==(12,3))

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

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

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

ברור שאני יכול לבדוק עם s[ 0 ].x ו s[ 0 ].y, אבל ככה זה פחות נוח ואלגנטי.

אתה צריך להגדיר אופרטור == עבור ה point שלך.

ואז תוכל: if(s[ 0 ]==s [ 5 ] )

כדי להשוות :

if(s[ 0 ]==(12,3))

אתה צריך להגדיר constructor ל point

ואז:

if(s[ 0 ]==point(12,3))

מה שיקרה הוא ייצור אובייקט ואז ישתמש באופרטור == שהגדרת.

להשוות בין שני אוביקטים הצלחתי.

פשוט עשיתי שהאופרטור [] מחזיר ערך התיחסות לxy (המקביל לpoint אצלי) ואז == מקבל ערך התיחסות.

בנוגע להשוואה בין אוביקט לנקודה:

כשאני עושה (xy(12,3, זה קורא לפונקציה הבונה נכון? מה שאומר שנוצר אוביקט חדש.

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

עכשיו יש לי עוד שאלה.

חלק מקוד:

struct snake

{

int length;

//some more vars and functions...

class xylist

{

xy &operator[](int i)

{

if(i<length)

//do something

}

//some more vars and functions...

};

};

כמו שאפשר לראות, xylist היא מחלקה בתוך snake. אחת הפונקציות שלה צריכה להשתמש בlength, ומשום מה זה לא עובד.

ניסיתי גם לפנות ל length בצורה הזאת:

length::

וגם ככה:

snake::length

אבל כלום לא עובד.

length הוא ציבורי ככה שאני לא מבין למה אי אפשר להשתמש בו.

אם אי אפשר לעשות את זה, אולי יש אפשרות לעשות שפונקציה של snake תוכל לגשת למשתנה של xylist?

גם זה יעזור לי.

האובייקט מושמד כאשר הוא יוצא מה scope, אתה יכול להוסיף ל destructor עם הדפסה למסך ואז תוכל לראות ממש.

ה length צריך להיות בתוך xylist מכיוון שזה האורך של הרשימה. מה שיפתור גם הרבה בעיות

ה length צריך להיות בתוך xylist מכיוון שזה האורך של הרשימה. מה שיפתור גם הרבה בעיות

אבל אז איך אני ניגש אליו מפונקציות של snake?

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

כמו שכבר אמרתי, אני צריך -

שיהיה משתנה length בxy ושאני אוכל לגשת אליו מsnake.

או

שיהיה משתנה length בxylist ושאני אוכל לגשת אליו מsnake.

או

שיהיה משתנה length בsnake ושאני אוכל לגשת אליו מxylist.

אחד מאלה.

כמו שכבר אמרתי, אני צריך -

שיהיה משתנה length בxy ושאני אוכל לגשת אליו מsnake.

או

שיהיה משתנה length בxylist ושאני אוכל לגשת אליו מsnake.

או

שיהיה משתנה length בsnake ושאני אוכל לגשת אליו מxylist.

אחד מאלה.

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

לשים את length ב XY - לא טוב מכיוון שזו לא תכונה של XY.

אפשר לשים אותו ב XYLIST מכיוון ש length זו תכונה של LIST

אפשר גם לשים snake אבל אין משמעות לLIST ללא אורך ולכן תהיה לך כפילות. בכלל, למקם משתנים גבוה מדי יוצר תוכנה "עם הרבה משתנים גלובליים"

אבל אז איך אני ניגש אליו מפונקציות של snake?

אפשר לשים בsnake פונקציה getLength שהולכת לLIST ומחזירה את האורך.

או להפוך את LIST ל public.

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

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

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