Discussion :

[ChriGoLioNaDor]

Bonjour,

J'ai une classe "awale", qui possède des méthodes, dont "prendre_graines()". Cette méthode est utilisée dans une autre méthode d'une autre classe "joueur"... Mon soucis est que je n'arrive pas à mettre cela en place :S

Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#include <iostream>
 
using namespace std;
 
class awale
{
	private:
		int	i;
		int	jeu[12];
 
	public:
		awale()
		{
			for(i=0;i<12;i++)
			{
				jeu[i]=4;
			}
		}
 
		void	afficher()
		{
			for (i=0;i<6;i++)
			{
				cout << jeu[i] << ' ';
			}
			cout << endl;
			for (i=6;i<12;i++)
			{
				cout << jeu[i] << ' ';
			}
			cout << endl;
		}
 
		int	nb_graines(int n)
		{
			return jeu[n];
		}
 
		float	prendre_graines(int n)
		{
			jeu[n]=0;
		}
 
		float	ajouter_graine(int n)
		{
			jeu[n]++;
		}
};
 
class joueur
{
 
	private:
		awale	mon_awale;
		int	score;
 
	public:
		joueur()
		{
			score=0;
		}
 
		bool	jouer(int n)
		{
			if (nb_graines(n)!=0)
			{
				int m=n;
				int nb=nb_graines(n);
				prendre_graines(n);
				for (int i=1;i<=nb;i++)
				{
					m++;
					if (m==12)
					{
						m=0;
					}
					ajouter_graine(m);
				}
				while ((nb_graines(m)==2 || nb_graines(m)==3) && m>=0 && m<6)
				{
					score+=nb_graines(m);
					prendre_graines(m);
					m--;
				}
			}
			else
			{
				return false;
			}
 
		}
};
 
int main()
{
	awale jeu;
	joueur joueur1;
 
	int n;
 
	jeu.afficher();
	do
	{
		cin >> n;
		n+=5;
		joueur1.jouer(n);
	}
	while (n>0 && n<=6);
	return 0;
}

Forcément, l'appel des méthodes "nb_graines()", "prendre_graines()", et "ajouter_graine()" déclenche une erreur de compilation.

Quelqu'un pourrait me donner un coup de main? Merci d'avance!

PS : je sais qu'il faut que je sépare mes classes dans des fichiers .h et .cpp, mais je voudrais régler ce soucis là avant....

[Laurent Gomila]

Ces fonctions sont membres de la classe awale, il faut donc les appeler avec une instance d'awale.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
mon_awale.nb_graines()
mon_awale.prendre_graines()
mon_awale.ajouter_graine()

[ChriGoLioNaDor]

Merci de ta réponse. Mon soucis venait du fait que je voulais réutiliser l'objet awale créé dans mon main (soit avec un pointeur, soit avec autre chose). Mais je n'y arrive pas :S

[koala01]

Salut,

De manière générale, si tu veux qu'une variable externe à une classe soit utilisée dans une fonction, il faut lui fournir cette variable comme argument...

Mais, l'avantage, c'est que tu peux tres bien surcharger les fonctions membres de tes différentes classes:

Ainsi, tu pourrais tres bien envisager ta classe Joueur sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
class joueur
{
    private:
        awale mon_awale;
        int score;
    public:
        /* Le constructeur que tu as dejà */
        joueur(){/*...*/}
        /* Idéalement, il serait pas mal de fournir un constructeur prenant un
         * awale en parametre (histoire de pouvoir directement initialiser 
         * mon_awale */
       joueur(const awale& aw):mon_awale(aw),score(0){}
       /* le destructeur, que tu as oublié */
       ~joueur(){/*...*/}
      /* la fonction Jouer telle que tu l'a écrite */
      bool jouer(int i)
      {
          /*...*/
      }
      /* une fonction jouer avec un awale qui n'a rien à voir avec celui qui
       * est membre de la classe */
      bool jouer(awale& aw,int i)
      {
          /* utiliser aw (dans l'exemple) au lieu de mon_awale chaque fois que 
           * tu as besoin d'un awale ;) */
      }
      /*...*/  
};

L'énorme avantage, c'est que le compilateur sera en mesure de choisir tout seul, en fonction des arguments passés à Jouer, s'il doit utiliser la fonction membre qui utilise le membre mon_awale ou non

J'en profite pour attirer ton attention sur le fait qu'il serait pas mal de prévoir un constructeur utilisant une référence constante sur un awale afin de permettre l'initialisation de mon_awale...

D'ailleurs, dans le cas où tu envisagerais de permettre de reprendre une partie sauvegardée, il serait carrément pas mal de prévoir le constructeur sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Jeu(const awale& aw, int score=0):mon_awale(aw),score(score){}

Le fait que le dernier parametre prenne un argument par défaut (le "=0") permet, selon les besoin d'utiliser la valeur par défaut (dans le cadre d'une nouvelle partie, selon l'exemple) ou d'utiliser la valeur fournie en parametre (dans le cadre d'une partie continuée)

[EDIT]lors de l'écriture du post, je ne savais pas si aw avait intéret à etre constant ou non... au vu du code de jouer, il semble que aw sera modifié dans la fonction jouer, et que aw ne doive par conséquent ne pas etre constant

[ChriGoLioNaDor]

Merci de ton aide. Je vois mieux comment faire, et en plus j'ai appris une nouvelle notation pour affecter les paramètres à une variable locale .