Discussion :

[ccinfonews]

Bonjour

j'ai 2 classes A et B
je voudrais modifier le tableau des 2 classes
"genre mon tableau en variable globale"

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
 
int monTableau[10];
 
classe A
{
     void ModifTableauA()
     {
          monTableau[5] = 4;
     }
}
 
classe B
{
     void ModifTableauB()
     {
          monTableau[8] = 1;
     }
}

merci

[LittleWhite]

Bonjour,

Ce que vous avez fait fonctionne. Mais bon, les variables globales, ce n'est pas vraiment bien (à part rare cas, voir FAQ ou débat précédents).

Pour revenir au problème, cela est possible, si les classes acceptent un pointeur sur le tableau (ou le pointeur du tableau, à vrai dire).
Le code sera du genre:

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
 
#include <cassert>
 
class A
{
    int* m_pTab;
    A(int* pTab)
        m_pTab:pTab
    {
        assert(m_pTab);
 
    }
 
    void foo()
    {
        m_pTab[2] = 42;
    }
}
 
class B
{
    int* m_pTab;
    B(int* pTab)
        m_pTab:pTab
    {
        assert(m_pTab);
    }
 
    void foo()
    {
        m_pTab[3] = 42;
    }
}
 
int main()
{
    int* pTab = new int[10];
    A a(pTab);
    B b(pTab);
 
    for ( unsigned int i = 0 ; i < 10 ; i++ )
    {
        std::cout << pTab[i] << std::endl;
    }
 
    delete pTab;
 
    return 0;
}

Mais, il y a certain points que je n'aime pas vraiment.
D'abord, le tableau est partagé dans deux classes différentes et cela me chagrine (qui gère réellement le tableau, qui a des droits d'accès / d'écritures). Que se passe t'il si les deux classes modifie la même case.
Et puis, quid des cas en multithread ...
De plus, dans mon code, cela ne marche que pour un tableau ayant une taille de 4 minimum. Pour nous protéger de cela, j'utiliserai plutôt un std::vector, qui connait le nombre d'éléments contenus.

Enfin voilà, je pense avoir au moins répondu à la "question" de base.

[ccinfonews]

pas facile la POO parfois
merci de la réponse

[Steph_ng8]

D'abord, le tableau est partagé dans deux classes différentes et cela me chagrine (qui gère réellement le tableau, qui a des droits d'accès / d'écritures).

Idem.
De plus, qui est responsable de sa création ? de sa destruction ?
Ce serait problématique d'essayer d'accéder à un de ses élément alors qu'il n'existe pas encore ou qu'il n'existe plus...

[ccinfonews]

en fait je pensais qu'on pouvait s'en sortir en utilisant les références ou pointeurs
en réfléchissant j'ai résolu le pb autrement mais je suis peut être sorti de la phylosophie de la POO
si un puriste pouvait me répondre à cette exemple simplifié qui fonctionne !

***** création d'un jeu de poker *****
- il y a une classe Donne, une classe Joueur et une classe Dealer
- autant d'instance Joueur que de joueur
- dans cette classe il y a un tableau public contenant les cartes du joueur
- la classe Donne gère la partie
- elle passe à la Classe Dealer, par une méthode, le tableau des cartes des joueurs vides par pointeur
- donc le tableau de la Classe Joueur contient les cartes distribuer

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
{
   public:
   int tabCarteJoueur[2];        // je sais un attribut public c'est pas terrible
   void ContenuDetabCarteJoueur()
   {
       // j'ai vérifier : après l'appel Donneur.Distribuer...
       // ici tabCarteJoueur[0] contient bien 12;
       // ici tabCarteJoueur[1] contient bien 25;
   }
}
 
class Dealer
{
   public:
   void Distribuer(int *tabCarteJoueur)
   {
       tabCarteJoueur[0] = 12;
       tabCarteJoueur[1] = 25;
   }
}
 
class Donne
{
   Joueur Joueur1;
   Dealer Donneur;
   // exemple pour un joueur pour ne pas compliquer
   Donneur.Distribuer(Joueur1.tabCarteJoueur);
}

[LittleWhite]

Personnellement, je n'aime toujours pas.

Dans une approche beaucoup plus objet, il faudrait que le jeu de carte soit un objet (JeuDeCarte) et les cartes elle même soit des objets (Carte).
Après, le jeu de carte, disposerai d'une fonction pioche, qui enlèverai une carte pour la donner (copie ou référence) à un joueur.
Et c'est le JeuDeCarte qui gère les cartes (création / destruction).

Enfin bref, mon approche n'a aucun rapport avec votre code (et elle est possiblement perfectible).
Là, ce qui me gène, c'est que vous donner accès à un membre d'une classe, et cela vers l'extérieur de celle-ci (un pointeur vers un membre). Ca casse le principe de l'encapsulation ...

[ccinfonews]

je sais bien que je ne respecte pas l'idée de base de la POO
par contre je pense que mon analyse tient la route

(une partie de l'analyse)
- la classe Donne : elle conduit la partie de A à Z - elle connait le principe du déroulement du jeu
- la classe Joueur : elle a des cartes - elle décide de qu'elle va faire en fonction de son jeu - elle a une somme de jetons
- la classe Dealer : elle se charge de mélanger les 52 cartes - donner 2 cartes à chaque joueur - montrer le flop, turn et river

je suis parti de cet exemple assez concret (et à la mode - poker) pour étudier la POO