אני צריך לעשות בC# מין תוכנה דומה לצייר, אך מונחת עצמים.

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

כולל לשנות צבע וכאלה

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

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

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

יש למישהו רעיון איך לשעות דבר כזה?

אתה שומר BIT MAP או את הצורות עצמן?

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

עקרונית אתה צריך משהו כזה:

קלאס אב אבסטרקטי "צורה" ששם יהיו כל הפונקצית - בלי מימוש כמובןף

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

כל שאר הצורות שלך יורשות ב "צורה" - אבל צריך לשמור על נהיררכיה נכונה:

ריבוע יורש הצורה, מלבן יורש מריבוע

עיגול יורש מצורה, אליפסה יורשת עיגול

משולש יורש מצורה

כגון את צריך מחלקת עזר כגון נקודה - שתכיל את הקורגינתחות XY

ריבוע HAS A נקודה חחחחח

ריבוע IS A צורה

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

קו IS A צורה אבל ריבוע ISN"T A קו......

בהצלחה

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

תראו, אלו פחות או יותר הקשרים שחשבתי עליהם,

קצת קשה לי עם הסינטקס של C#, אחרי שהתרגלתי לC++ אני לא יודע ממש לעבור,

למשל בצורה האבסטרקטית, מה אני שם?

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

פשוט לכתוב קלאס צורה אבסטרקטי שאין בו אפילו אף מתודה?

פעם עשיתי משהו דומה בC, אבל שם זה היה שונה, היה לי קלאס צורה שני קוסטרקטורים, אחד דיפולטי, והשני מתקבל שני ints ופונקציה וירטואלית שמחשבת שטח

פה אין לי מה לעשות,

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

בקוסטרקטור , הוא פשוט יהיה ריק, ואיזה פונקציות וירטואליות לעזאזל אני אצטרך?

בסוף, חשבתי לשמור את כל הצורות הרשימה מקושורת של SHAPE,

את ההיררכיה יש לי... אני נתקעתי קצת במימוש

class אבסטרקטי הוא כמו interface בג'אוה. הוא מגדיר את הפונקציונליות המשותפת של האובייקטים בלי לכלול את המימוש שלה.

הדבר הבסיסי שאתה אמור לדעת לעשות עם צורה, זה לצייר אותה, לא?

לכן הגיוני שתהיה לך פונקציה וירטואלית ב- class shape שמציירת את הצורה במיקום שאומרים לה.

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

אין לך שום בעיה להחזיק רשימה של references/pointers ל- shape, וכשאתה קורא לפונקציה וירטואלית, הפונקציה הנכונה תיקרא על כל אובייקט ברשימה.

יש איזו שהיא בעיה

הDRAW הוירטואלית אבסטרקטית צריכה בהכרזה שלה לקבל פרמטרים,

ואותם פרמטרים צריכים לקבל הDRAW של כל הצורות האחרות לא?

לפי מה שאני מבין, ה- draw אמורה לקבל רק מיקום, ומשהו דומה ל- device context שעליו אמורים לצייר (אם הוא לא גלובלי)

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

עקרונית בDRAW וFILL יש אותו מספר פרמטרים גם למלבן וגם לאליפסה,

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

draw

מקבלת סוג מברשת נקודות התחלה רוחב וגובה

אבל לפוליגון

היא גם מקבלת מערך של קודקודים

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

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

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

לא מבין איפה הבעיה פה

אני פשוט זוכר שסי++, ברגע שהגדרת פונקציה וירטואלית = 0, אז אם היו לה פרמטרים מסויימים, לפונקציות הדרוסות היו צריכים להיות אותם פרמטרים

מסר ל- ktbnus:

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

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

הרעיון הוא שכל המידע שנדרש כדי לצייר צורה מסוימת נשמר על הצורה.

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

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

מסר ל- ktbnus:

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

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

הרעיון הוא שכל המידע שנדרש כדי לצייר צורה מסוימת נשמר על הצורה.

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

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

טוב. נתחיל מהתחלה:

איפה ההיגיון בלדרוס פונקציה אם פונקציה שיש לה אותה חתימה???@?@ זות שגיעת קומפילציה - שתי פונקציות זהות!

דבר שני:

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

בן(יורשת)

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

ושוב נותר לי לענות ב-

אתה מתבלבל בין overload (או "העמסה" - שתי פונקציות עם שם זהה וחתימה אחרת)

לבין override ("דריסה") - פונקציה ב- class הבן עם אותה חתימה כמו זו ב- class האב.

ב- C# אתה חייב להגיד על פונקציה כזו אם היא override או שהיא מסתירה פונקציה באב (אני לא סגור על ה- keyword, בדלפי זה reintroduce)

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

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

טוב, הוויכוח היה מעניין אבל לא בא לי ללכת

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

ובהצלחה בפרוייקט לפותח התר'אד