קודם כל התרגיל מצורף בקובץ.
כרגע אני מתמקד ב-2 הקלאסים הראשיים: Team ו-Game.
לגבי vector of Games played by the team אני לא ממש מבין אם רוצים ממני מערך של משחקים לכל קבוצה או שאולי מתכוונים למערך של כל המשחקים של כל הקבוצות שנראה לי יותר הגיוני.
המתודה של Add Game ב-Class Team: אם הקלאס אבסטרקטי אי אפשר לייצר ממנו אובייקטים ולכן אני לא יכול להוסיף משחק אז מה הקטע פה ? איך עושים את זה ?
int GameCount(Team t2) - במתודה הזו הייתי שמח לעזרה כי לא ממש הולך לי, מה שיש לי עד עכשיו זה זה:

[/code]

קוד:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.IO;


namespace test
{
    public class IncorrectTeamID : ApplicationException
    {
        public IncorrectTeamID(string message)
            : base(message)
        {
        }
    }


    public class Game
    {
        int HostTeamID;
        int GuestTeamID;
        int HostGoals;
        int GuestGoals;


        public Game(int hostTeamId, int guestTeamID, int hostGoals, int guestGoals)
        {
            this.HostTeamID = hostTeamId;
            this.GuestTeamID = guestTeamID;
            this.HostGoals = hostGoals;
            this.GuestGoals = guestGoals;
        }


        public int Host_Team_ID
        {
            get { return this.HostTeamID; }
        }


        public int Guest_Team_ID
        {
            get { return this.GuestTeamID; }
        }


        public int Host_Goals
        {
            get { return this.HostGoals; }
        }


        public int Guest_Goals
        {
            get { return this.GuestGoals; }
        }


        public override string ToString()
        {
            return "Host Team ID :" + HostTeamID + "Host Team Goals: " + HostGoals + "Guest Team ID: " + GuestTeamID + "Guest Team Goals: " + GuestGoals;
        }
    }


    public abstract class Team : IComparable
    {
        int TeamID;
        string TeamName;
        int gameCount = 0;
        Game[] GamesArray = new Game[50];


        public Team(int teamID, string teamName)
        {
            if (teamID < 1 || teamID > 24)
            {
                throw new IncorrectTeamID("Team ID Should Be between 1 and 24: " + teamID);
            }


            this.TeamID = teamID;
            this.TeamName = teamName;
        }


        public void AddGame(Game g)
        {
            GamesArray[gameCount] = g;
            gameCount++;
        }


        public int Team_ID
        {
            get { return this.TeamID; }
        }


        public string Team_Name
        {
            get { return this.TeamName; }
        }


        public override string ToString()
        {
            return "Team ID: " + TeamID + " " + "Team Name: " + TeamName;
        }


        public int GameCount()
        {
            return this.gameCount;
        }


        public int GameCount(Team t2)
        {
            int count = 0;


            for (int i = 0; i < GamesArray.Length; i++)
            {
                if ()
                {
                    
                }
            }


            return count;
        }


        public int CompareTo(object obj)
        {
            throw new NotImplementedException();
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            Team t1 = new Team(1, "a");
            Team t2 = new Team(2, "b");
            Team t3 = new Team(3, "c");
            Team t4 = new Team(4, "d");




            Game g1 = new Game(1, 2, 3, 1);
            Game g2 = new Game(1, 2, 6, 4);
            Game g3 = new Game(1, 2, 0, 4);
            Game g4 = new Game(1, 2, 2, 2);
            Game g5 = new Game(3, 4, 3, 6);
            Game g6 = new Game(3, 1, 0, 0);




            Console.WriteLine(t1.ToString());
            Console.WriteLine(t2.ToString());


            Console.WriteLine("ADD GAME");


            t1.AddGame(g1);
            t1.AddGame(g2);
            t1.AddGame(g3);
            t1.AddGame(g4);


            int result = t1.GameCount(t2);
            Console.WriteLine(result);


            int g1_get = g1.Host_Goals;
            int g2_get = g1.Guest_Goals;


            Console.WriteLine(g1_get);
            Console.WriteLine(g2_get);


            


            Console.ReadLine();
        }
    }
}

איפה ההוראות של התרגיל?

https://2011-uploaded.fresh.co.il/2...1/82176202.docx

אני גם לא מבין בקלאס של הקב' כדורסל וכדורגל את המתודה int score: זו החתימה שלה או זה מה שהיא מקבלת ?

1. ב-vector of Games played by the team הם רוצים מערך מסוג משחק שכל תא בו מצביע על משחק שבו משחקת הקבוצה.

2. AddGame פשוט לוקחת את משחק כלשהו ומוסיפה אותו למערך המשחקים של הקבוצה, כלומר כביכול מובטח לך שאם אתה ניגש לתא במערך GamesArray בתוך אובייקט של קבוצה - אז הקבוצה שיחקה במשחק הזה. שים לב לקשר לסעיף 1.

3. int GameCount(Team t2)‎ - אתה צריך לעבור על כל המשחקים שנמצאים בתוך האובייקט שקורא לפונקציה (רמז: this.GamesArray) ולבדוק בכמה משחקים הקבוצה t2, שאותה קיבלת כפרמטר, משחקת.

4. int Score זה "מאפיין" (Property) של המחלקה, ממש כמו שעשית ב-Host_Goals לדוגמה.

אוקיי תודה רבה ובקשר למתודה הזו:

איך אני משתמש ב-OUT ?

[/code]

קוד:

        public bool GetTeam(int teamID, out Team team)
        {
            for (int i = 0; i < AllTeams.Length; i++)
            {
                if (AllTeams[i].Team_ID == teamID)
                {              
                    return true;
                }

                else
                {
                    return false;
                }
            }
        }

אני מקבל שגיאה שאני צריך להוסיף את ה-OUT

ועדיין לא ממש הבנתי מה זה int Score

לגבי ה-out:
זוהי מילה שמורה אשר מאפשרת לך "להחזיר" יותר ממשתנה אחד בסוף פעולת הפונקציה/מתודה.
מה שאתה צריך לעשות זה פשוט לשים במשתנה team את הקבוצה שמצאת, אם היא קיימת.

לגבי ה-int Score, אני אתן לך רמז:

קוד:

public int Score {
	get {
		...
	}
}

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

לגבי המתודה עם ה-out איפה אני רושם את המשתנה שנכנס ל-out ? מחוץ ללולאה ?
הקומפיילר לא מקבל את זה:

קוד:

        public bool GetTeam(int teamID, out Team team)
        {
            for (int i = 0; i < AllTeams.Length; i++)
            {
                if (AllTeams[i].Team_ID == teamID)
                {                                  
                    return true;                    
                }

                else
                {
                    return false;
                }

                out Team t = AllTeams[i];
            }
        }

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

קוד:

team = ...;

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

זה מה שעשיתי וזה לא מקבל:

קוד:

        public bool GetTeam(int teamID, out Team team)
        {
            for (int i = 0; i < AllTeams.Length; i++)
            {
                if (AllTeams[i].Team_ID == teamID)
                {
                    return true;
                }

                else
                {
                    return false;
                }

                Team = AllTeams[i];
            }


        }

אגב בעניין מתודת ה-vector of Games played by the team, אני אמור לבנות מערך לכל קבוצה ?
לא ממש הבנתי איך אני מממש את זה

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

ואין לך מתודה של vector of game played by the team, זהו שדה באובייקט Team.
תראה, מדובר על מערך בתוך האובייקט Team שמכיל אובייקטים מסוג משחק. אתה צריך להגיע למצב שבו כל משחק שיש לך במערך הזה - הקבוצה שיחקה בו.

לדוגמה - נניח ויש לך את המשתנה t1 שמייצג קבוצה מסויימת, אז כדי לגשת לכל המשחקים שבהם שיחקה הקבוצה אתה צריך לגשת ל-t1.GamesArray. כדי לגשת למשחק מסויים (ששוב, הקבוצה t1 שיחקה בו) - אתה יכול לגשת אליו כך:

קוד:

t1.GamesArray[12]

מקווה שהבנת את הכוונה.

אני מבין ש-vector of game played by the team הוא שדה ב-CLASS וזה בדיוק מה שעשיתי אבל איך כשאני עושה למשל:

קוד:

team1.AddGame(game1);

אז המשחק נכנס למערך וזה סבבה אבל כשאני יוסיף אח"כ משחקים נוספים של קב' נוספות הם יכנסו לאותו המערך אז איך אני יודע כמה משחקים קב' מסויימת שיחקה ?

שים לב שהמתודה AddGame מגדילה ב-1 את השדה gameCount באובייקט Team, כך שאתה יכול לדעת כמה משחקים היא שיחקה ע"י שליפת השדה הזה.

אבל אם אני מכניס 3 משחקים לקב' 1 ו-4 משחקים לקב' 2 ה-GamCount גדל ל-5 אבל איך אני יודע כמה כל קבוצה שיחקה ?
ועוד משהו שאני לא הצלחתי זה ה-int Score לא ממש הולך לי ב-Class Team איך לממש אותו
אם ניצחון זה 3 נק' (אח"כ מממשים אותו בקלאס של כדורגל ובקלאס של כדורסל) הפסד - נק' אחת, איך אני אמור לעשות את זה ?
ניסיתי לסרוק את המערך של המשחקים אבל לא הלך.

ציטוט:

אבל אם אני מכניס 3 משחקים לקב' 1 ו-4 משחקים לקב' 2 ה-GamCount גדל ל-5 אבל איך אני יודע כמה כל קבוצה שיחקה ?

כל משחק שאתה מוסיף לאובייקט מסוג Team מעלה את המונה של ה-gameCount של אותו האובייקט בלבד. כלומר, אם אתה עושה משהו כזה:

קוד:

t1.AddGame(game1);
t1.AddGame(game2);
t2.AddGame(game3);

אז בקבוצה t1 השדה gameCount יכיל 2, ואילו בקבוצה t2 השדה gameCount יכיל 1.

ציטוט:

ועוד משהו שאני לא הצלחתי זה ה-int Score לא ממש הולך לי ב-Class Team איך לממש אותו אם ניצחון זה 3 נק' (אח"כ מממשים אותו בקלאס של כדורגל ובקלאס של כדורסל) הפסד - נק' אחת, איך אני אמור לעשות את זה ? ניסיתי לסרוק את המערך של המשחקים אבל לא הלך.

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

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

מה הכוונה המקרה הראשון? אתה מדבר על המתודה השנייה של GameCount עם הפרמטר Team t2?

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

אני מתכוון שצריך לממש את ה-int Score ב-class FootballTeam וב-class BasketballTeam אבל לפני זה לכתוב את הפרופרטי הזה ב-Class Team (רשום abstract property that gives the score of the team)

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

עד כמה שאני הבנתי, אתה רק צריך להכריז על מאפיין (Property) אבסטרקטי, בצורה הזו:

קוד:

	public abstract int Score {
		get;
	}

נכון אבל ב-class FootballTeam וב-class BasketballTeam אני צריך לממש אותו (2 נק' לניצחון בכדורסל 1 להפסד ובכדורגל 3 לניצחון 1 לתיקו) ואת זה אני לא מצליח.

זה מה שעשיתי במחלקה BasketballTeam, נסה לעשות את אותו הדבר (כמובן עם הבדיקה של התיקו..) ב-FootballTeam:

קוד:

		public int Score {
			get {
				int scoreCount = 0;
				for (int i = 0; i < GamesArray.Length; i++) {
					if (GamesArray[i].Guest_Team_ID == this.Team_ID) {
						if (GamesArray[i].Guest_Goals > GamesArray[i].Host_Goals)
							scoreCount += 2;
					}
					else {
						if (GamesArray[i].Host_Goals > GamesArray[i].Guest_Goals)
							 scoreCount += 2;
					}
				}
				return scoreCount;
			}
		}