classes et fonctions entre membres

Version imprimable

07/11/2008, 23h23
jahmanzaar

classes et fonctions entre membres

bonjour bonjour .....
aujourd'hui, problème avec des fonctions qui agissent sur des variables membres d'une autre classe.

Je dévellope :
j'ai donc une belle classe Actor avec un tas de variables membres, constructeur et méthodes.
Je voudrais maintenant avoir une classe contenant des fonctions modifiant les valeurs des variables d'un membre de Actor en fonction des valeurs des variables d'un autre membre de Actor .

Et la, je sèche :arf: :arf: et :arf:

En gros, je piges pas comment je peut écrire ce genre de classe, sans réel membre à déclarer (pas de new Actor ou new qqchose à garder en memoire).

J'ai rien compris au C++ ?
J'ai rien compris au classes ?
Un détail m'échappe ?
...
Quelqu'un peut il me mettre sur la voie ?
merci d'avance.
08/11/2008, 00h16
Klaim

Je ne vois pas bien le problème, si je suis ce que tu dis tu essaies juste d'accéder à un membre d'une classe par une autre classe? Il y a des tas de moyen de le faire...

Je remarque par contre qu'il se peut que tu n'utilises pas les bons termes pour expliquer ton problème :

Citation:

En gros, je piges pas comment je peut écrire ce genre de classe, sans réel membre à déclarer (pas de new Actor ou new qqchose à garder en memoire).

Cette phrase n'a aucun sens, mais je devine que tu tentes d'accéder à une instance d'Actor sans avoir aucune référence sur cette instance? Si c'est bien ça, alors c'est impossible parcequ'absurde : a part si ton membre est statique (et donc commun à toutes les instances d'Actor), tu as besoin d'une référence/pointeur vers une instance d'Actor pour savoir quel objet de type Actor tu dois manipuler.

Je suis pas sur que ça va t'aider...

Salut,

Voyons si j'ai bien compris le problème:

Tu as deux instances (objets) de type Actor, que nous nommerons pour l'occasion act1 et act2.

Et tu souhaiterais créer une classe (nommons la Mediator, par exemple) qui irait interroger act1 sur la valeur d'un de ses membre et qui provoquerait la modification d'un des membres de act2, est-ce bien cela :question:

Ne serait-il pas opportun de se dire que la classe Actor doit garder la responsabilité de la modification de ses membres :question:

La seule responsabilité de la classe Mediator devenant alors de questionner act1 et act2 sur la valeur du membre adéquat, et, fonction de la réponse des deux, de choisir auquel elle enverra comme instruction "met toi à jour en calculant sur la base de ...)

Je vais prendre un exemple pour essayer de me faire comprendre:

act1 et act2 sont ennemis jurés, et ils se rencontrent au coin d'un bois, un soir de pleine lune (cela n'a rien à voir, mais ca met l'ambiance :D)

Seulement, il y en a un qui a des réactions très rapides, mais qui frappe de façon moins violente, et l'autre, plus lent, qui frappe beaucoup plus fort que le premier.

Le but de ta classe serait donc de:

demander à act1 avec quelle vitesse il est en mesure d'attaquer
demander la même chose à act2
de demander à act1 - car on en aura besoin - le nombre de dégat "de base" (donc hors pénalité d'armure) qu'il est en mesure de faire
de demander la même chose à act2.

A partir de là, notre Mediator travaillerais selon un shéma relativement simple sous la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 si (vitesseAct1>vitesseAct2) act1->attaque() //il devra se "reposer" apres son attaque ;) act2->subit(degatsAct1) // il va calculer, en fonction de l'armure qu'il // porte, les dégats réellement infligés (et peut // etre en mourir) sinon si (vitesseAct1<vitesseAct2) // les roles sont inversés act2->attaque() //il devra se "reposer" apres son attaque ;) act1->subit(degatsAct2) // il va calculer, en fonction de l'armure qu'il // porte, les dégats réellement infligés (et peut // etre en mourir) sinon // les deux attaquent en meme temps, et subissent les dégats // occasionné par l'adversaire act2->attaque() act1->attaque() act1->subit(degatsAct2) act2->subit(degatAct1) fin si
Est-ce que cela ressemble - dans l'ensemble - à ce que tu souhaite faire :question:

08/11/2008, 21h33
jahmanzaar

koala, c'est effectivement cela qui me pose probleme :

je vois pas bien comment ecrire la fameuse classe médiator, surtout concernant un éventuel constructeur;
de plus devrais avoir un :

Code:

supermédiator = new mediator

quelque part dans mon code ?

A vrai dire, ce pourrait très bien être une fonction libre proche de

Code:

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
void manageAttack(Actor& act1, Actor& act2)
{
    /* récupération des valeurs qui nous intéressent */
    unsigned int speed1 = act1.getSpeed();
    unsigned int speed2 = act2.getSpeed()
    unsigned int strengh1=act1.getStrengh();
    unsigned int strengh2= act2.getStreng();
    if(speed1>speed2)
    {
        act1.attack();
        act2.defend(strengh1);
    }
    else if(speed1==speed2)
    {
        act1.attack();
        act2.attack();
        act1.defend(strengh2);
        act2.defend(strengh1);
    }
    else
    {
        act2.attack();
        act1.defend(strengh1);
    }
}

Maintenant, il est possible - selon la situation dans laquelle tu te trouve - d'envisager de donner cette fonction à la classe qui a comme responsabilité de... gérer les acteurs.

En se basant sur le fait que la classe ActorManager, spécialement créée pour l'occasion, dont la responsabilité est de gérer l'ensemble des différents acteurs pourrait être un singleton (car il ne devrait en exister qu'une et une seule instance en permanence et qu'elle devra - à peu de chose près - exister du début à la fin de l'application) et contient d'un coté la collection de tous les acteurs non joueurs (PNJ / NPC) et de l'autre... le joueur, sous une forme proche de

Code:

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
class ActorManager
{
    public:
        static ActorManager& instance()
        {
            if(!inst)
                inst=new ActorManager;
            return *inst;
        }
        static void destroy()
        {
            delete inst;
            inst = 0;
        }
        /* la méthode qui permet de gérer l'attaque */
        void manageAttack();
        /* surement quelques méthodes utiles pour gérer les
         * différents acteurs, que je laisse sur le coté 
         */ 
    private:
        /* seul le gestionnaire peut se créer*/
        ActorManager(){}
        /* et se détruire */
        ~ActorManager(){}
        /* la copie et l'assignation sont interdites */
        ActorManager(const ActorManager&);
        ActorManager& operator= (const ActorManager&);
        /* l'instance réelle */
        static ActorManager* inst;
        /* la collection de PNJ */
        std::list<Actor> npcs;
        /* et le joueur */
        Actor gamer;
}

n'oublions pas, l'initialisation du membre statique dans un et un seul fichier d'implémentation, sous la forme de

Code:

ActorManager* ActorManager::inst = NULL;

La fonction pourrait ressembler à

Code:

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
void ActorManager::manageAttack()
{
    /* un algorithme quelconque pour trouver un PNJ qui veut attaquer
     * le joueur (à implémenter selon tes besoins
     */
    Actor attacker=findAttacker();
    /* comme il n'y a peut etre aucun candidat à l'attaque, 
     * nous testons le fait que nous en avons trouvé un...
     */
    if(attacker!=npcs.end())
    {
        /* récupération des valeurs qui nous intéressent, adaptée
         * à la nouvelle situation
         */
        unsigned int speed1 = gamer.getSpeed();
        unsigned int speed2 = attacker.getSpeed()
        unsigned int strengh1=gamer.getStrengh();
        unsigned int strengh2= attacker.getStreng();
        if(speed1>speed2)
        {
            gamer.attack();
            attacker.defend(strengh1);
        }
        else if(speed1==speed2)
        {
            gamer.attack();
            attacker.attack();
            gamer.defend(strengh2);
            attacker.defend(strengh1);
        }
        else
        {
            attacker.attack();
            gamer.defend(strengh1);
        }
    }  
}

[EDIT]Quand je parle d'une classe "spécialement créée pour l'occasion", je ment effrontément, car je l'introduit spécialement ici, mais tu te rendra surement compte à l'usage que cette classe devient l'une des classes maitresse de ton application ;)

En outre, j'ai oublié de préciser comment faire le lien entre l'acteur et le gestionnaire d'acteurs (dans le sens acteur --> gestionnaire).

Lorsque tu veux que l'acteur passe la main au gestionnaire pour gérer l'attaque éventuelle, par exemple à l'occasion d'un déplacement, cela se fera sous une forme proche de

Code:

1
2
3
4
5
6
7
void Actor::move()
{
   /* toute la gestion associée au déplacement de l'acteur, que je te laisse
    * le soin d'implémenter
    */
    ActorManager::instance().mangageAttack();
}

10/11/2008, 20h28
jahmanzaar

merci beaucoup pour ces éclaircissements forts clairs;

je m'en vais de ce pas faire mouliner tout cela et repasserais je l'espère ajouter le ti panneau 'résolu' :D