להפתעתי היו לי מספר מועט של בעיות והנה הם:

1. אני לא מצליח לגשת לפונקציה של מחלקה ככה:

Deck.newDeck(stock);

המחלקה:

#include "Card.h"
#include <list>
#include <algorithm>

using namespace std;

class Deck{
private:
	static list<Card> deck;
	static int integration;

public:
	static const int NUM_OF_CARDS=60;

	Deck();
	~Deck();
	static void newDeck(list<Card> &d);
};

קוד הפונקציה:

void Deck::newDeck(list<Card> &d){
	d=deck;
}

2. מאותה מחלקה אני מנסה לאתחל את המשתנה בקובץ CPP ככה

Deck::integration=0;

לא נותן, הוא רוצה שאני יכתוב INT בהתחלה, אבל אז אני מגדיר משתנה חדש לא?

3. מאותה מחלקה, המימוש של הדיסטרקטור:

Deck::~Deck(){
	~list(deck);
}

לא מצליח להרוס את רשימה שלי.. למה?

4. לולאה של ENUM לא טובה, הוא לא מקבל ת++

for (Rank rankcount = ONE; rankcount <= COLOR; rankcount++)

אם אני עובד עם INT הוא לא מקבל אותם בקריאה לפונקציה

5. בעיה בשורה הזו(או בכל שורה שאני מנסה להוסיף יותר מ1 לIT):

deck.push_back(*(it+rand));

מתוך:

Player::Player(list<Card>& d, string n){
	name=n;
	int rand;
	list<Card>::iterator it;
	for(int i=0;i<8;++i){
		it=d.begin();
		rand=(int)(rand()%(d.size()-(Deck.NUM_OF_CARDS-d.size())));
		deck.push_back(*(it+rand));
		d.erase(it+rand);
	}
}

מקווה שתצליחו להאיר את עיניי... D=

תודה.

1. לפונקציה סטאטית קוראים ככה:

Deck::newDec(stock);

2. תוסיף int, זה בסדר.

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

4. תשתמש ב-int ובקריאה לפונקציה תעשה cast

5.

שים לב לסדר של הסוגריים. קודם אתה צריך "להוציא" מהפוינטר.

deck.push_back((*it)+rand);

תודה.

5. עדין לא נפתר הוא נותן לי מלא ארורים על שני השורות האלה

deck.push_back((*it)+rand);
		d.remove((*it)+rand);

יש בעיה גם בRAND

	srand(time(NULL));
		int rand=(int)(rand()%d.size());

term does not evaluate to a function taking 0 arguments

רק עכשיו קראתי את כול הקוד ב-5.

(אז תתעלם מהתשובה הקודמת שלי)

אתה עושה שם בלאגן.

דבר ראשון, אתה לא יכול להגדיר

int rand;

ואז לקרוא לפונקציה rand().

כרגע דרסת אותה.

דבר שני,

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

אחרת, אתה צריך לקדם ידנית את האיטרטור rand פעמים.

והערה קטנה נוספת, מומלץ להשתמש ב-prefix למשתנים ששיכים למחלקה,

נגיד mDeck או m_Deck לפרטיים ו-sIntegration לסטאטים.

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

D= כבר לא במודע אני קורא למשתנה שמחזיק מספר רנדומלי RAND.

בכל אופן רציתי לתרגל עם רשימות...

אמממ, בעיה נוספת שצצה בעת קומפילציה

1>Deck.obj : error LNK2001: unresolved external symbol "private: static class std::list<class Card,class std::allocator<class Card> > Deck::deck" (?deck@Deck@@0V?$list@VCard@@V?$allocator@VCard@@@std@@@std@@A)

אתה חייב לאתחל את כל האיברים הסטטיים בקלאס שלך.

לא אתחלת את deck.

ניסיתי לעשות משהו כזה

list<Card> Deck::deck.push_back(Card(ONE,RED));

לא נתן....

אל תעשה שעטנז.

פשוט תאתחל אותו כאילו אתה מאתחל משתנה:

list<Card> Deck::deck;

זה יקרא לקונסטרקטור הדיפולטי שלו.

מקצה הערות, פירושים וחידודים (לא, לא הדברים האלה שיורדים מעפרון):

1)

ה-iterators של רשימה הם לא random access iterators ולכן לא ניתן לעשות להם + אלא רק ++ או --.

תשתמש באלגוריתם advance:

#include <algorithm>

...
std::advance( it, rand_amnt );
...

2)

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

השורה: list<Card> Deck::deck; בעצם היא הגדרה (definition) של המשתנה ומקצה לסימבול אחסון בקובץ שבו היתה ההגדרה.

לכן, לדוגמא, אם תכניס את השורה הזו פעמיים בשני קבצי CPP שונים, תקבל link error על כך שאותו משתנה קיים פעמיים!

אתחול המשתנה הוא פשוט תוצאת לוואי מכך שהוא הוגדר. אם deck היה מסוג int, לדוגמא, או ללא constructor, אז ההגדרה לא היתה מאתחלת אותו.

טוב לדעת, תודה.