Appel d'une classe C++: c'est possible?

Salut,

Aussi longtemps que:
le fichier d'implémentation (Quantif.cpp, dans ton cas) inclut le fichier d'ent-tête de la classe que tu souhaite utiliser et
tu disposes d'une instance de la classe à partir de laquelle tu puisse faire appel au différentes fonctions membres (à moins qu'elles ne soient statiques)

tu seras en mesure de faire appel à toutes les fonctions membres que tu veux, dans l'ordre que tu veux, aussi souvent que tu le voudras ;)

Bien sur, les fonctions auxquelles tu feras appel et l'ordre dans lequel tu y fera appel devront correspondre au besoin que tu essayes de remplir, mais, ca, c'est une question d'algorithmique ;)

Pour bien fixer les choses, voici un petit exemple :
Imaginons que nous ayons une classe -- définie dans le fichier d'en-tête Outil.hpp 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 /* Les gardes anti-inclusion vont éviter d'avoir plusieurs définitions de la même classe si, par malheur * (sans doute à cause du jeu des inclusions en cascade),le fichier venait à être inclut plusieurs fois * dans un fichier d'implémentation */ #ifndef OUTIL_HPP_INCLUDED #define OUTIL_HPP_INCLUDED class Outil{ public: /* l'utilisateur n'a pas besoin de savoir ce que font les différentes en fonctions en internes * tout ce qu'il doit savoir, c'est que les fonctions existent (et, dans l'idéal, quel besoin elle permettent de remplir- * * Aussi longtemps qu'il dispose du prototype complet de la fonction, le compilateur sera content */ void foo(); int bar(); float truc(); void blahblah(); void machin(int); void bidule(float); /* bien sur, ces fonctions risques d'avoir besoin de données pour fonctionner, * mais, l'utilisateur de la classe Outil n'a pas besoin de les connaitre ;) */ private: /* ... */ }; #endif // OUTIL_HPP_INCLUDED
Tu remarqueras que les noms sont bidons, mais c'est uniquement parce que je n'ai pas défini l'usage que je ferai de cette classe. Quoi qu'il en soit, je dispose de deux possibilités pour utiliser une instance de cette classe:

soit, je me rend compte que plusieurs fonction de la "classe utilisatrice" vont manipuler la même instance de la classe, et je décide d'en faire une donnée membre
Soit, je crées (ou je transmet comme paramètre) une instance locale (à une fonction bien particulière) de la classe et je l'utilise,

Dans le premier cas, le compilateur devra connaitre cette classe Outil lorsqu'il utilise lefichier d'en-tête de la "classe utilisatrice", et nous devrons donc (*)inclure directement le fichier d'en-tête de la classe Outil dans le fichier de la classe utilisatrice, ce qui nous amènerait à créer la classe, définie dans le fichier d'en-tête Utilisateur_1.hpp sous une forme proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #ifndef UTILISTATEUR_1_HPP_INCLUDED #define UTILISTATEUR_1_HPP_INCLUDED #include <Outil.hpp> class Utilisateur_1{ /* pour montrer que je peux utiliser n'importe quelle fonction * exposée par la classe Outil, dans n'importe quel ordre, * aussi souvent que je le veux */ public: void doSomething(); private: Outil m_outil; }; #endif // UTILISTATEUR_1_HPP_INCLUDED
et dont l'implémentaiton -- fournie dans le fichier Utilisateur_1.cpp -- pourrait ressembler à quelque chose comme
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 /* Parce que le compilateur doit connaitre la classe Utilisateur_1 * Note que, par le jeu des inclusions en cascades, il connait aussi la classe Outil */ #include <Utilisateur_1.hpp> void Utilisateur_1::doSomething(){ /* Cette fonction faisant partie intégrante de la classe Utilisateur_1, * elle peut accéder sans problème à la donnée m_outil, et à toutes ses * fonction publiques */ int test = m_outil.foo(); // récupère la valeur renvoyée par la fonction foo de la classe Outil float autre = m_outil.bar(); // récupère la valeur renvoyée par la fonction bar de la classe Outil for(int i=0; i<test; ++i){ m_outil.machin(i); // je peux faire appel aux différentes fonction m_outil.bidule(autre); // aussi souvent que je le souhaite } }
(*) En fait, le compilateur doit connaitre l'intégralité de la classe Outil pour pouvoir déterminer la place que m_outil prend en mémoire dans la classe Utilisateur_1. Si m_outil n'avait été qu'une référence (ou un pointeur) vers une instance de la classe Outil, nous aurions pu nous contenter d'une déclaration anticipée au niveau du fichier d'en-tête, et d'inclure le fichier <Outil.hpp> directement dans Utilisateur_1.cpp ;)

Dans le deuxième cas, nous pourrions définir -- dans le fichier d'en-tête Brol.hpp -- une classe ressemblant à
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #ifndef BROL_HPP_INCLUDED #define BROL_HPP_INCLUDED /* une déclaration anticipée de la classe outil, parce que le compilateur doit savoir que la classe existe * lorsqu'il rencontre la déclaration de la fonction bidule */ class Outil; class Brol{ public: /* une fonction qui utilisera une instance locale de la classe Outil */ void test() /* une fonction qui prend une instance de la classe Outil en paramètre (**) */ void otherThing(Outil &); /* tout le reste */ }; #endif //
et dont l'implémentation --fournie dans Brol.cpp -- pourrait être 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 // Parce que le compilateur doit connaitre la classe Brol #include <Brol.hpp> // parce que le compilateur doit tout savoir sur la classe Outil (sinon,il ne pourra pas l'utiliser) #include <Outil.hpp> void Brol::test(){ /* je peux créer une instance locale de la classe Outil */ Outil outil; /* et je peux faire appel à n'importe quelle fonction publique de cette classe * dans n'importe quel ordre, aussi souvent que je le veux */ float autre = outil.bar(); // récupère la valeur renvoyée par la fonction bar de la classe Outil int test = outil.foo(); // récupère la valeur renvoyée par la fonction foo de la classe Outil for(int i=0; i<test; ++i){ outil.bidule(autre); // aussi souvent que je le souhaite outil.machin(i); // je peux faire appel aux différentes fonction } } /* on doit nommer les paramètres ;) */ void Brol::otherThing(Outil & outil){ /* je peux faire appel à n'importe quelle fonction publique de cette classe * dans n'importe quel ordre, aussi souvent que je le veux */ float autre = outil.bar(); // récupère la valeur renvoyée par la fonction bar de la classe Outil int test = outil.foo(); // récupère la valeur renvoyée par la fonction foo de la classe Outil for(int i=0; i<test; ++i){ outil.bidule(autre); // aussi souvent que je le souhaite outil.machin(i); // je peux faire appel aux différentes fonction } }
(**) Par habitude, il est toujours intéressant de transmettre tout ce qui est "plus gros qu'un type primitif" (comprend: plus gros qu'un long long ou qu'un long double par référence, éventuellement constante si la fonction appelée ne doit pas pouvoir modifier l'instance transmise en paramètre ;)