Discussion :

[soniaIRM]

Bonjour tout le monde,

Pour être rapide, mon problème est le suivant:

Dans ma solution, j'ai une classe C++ "DetectionContour.cpp" qui contient plusieurs méthodes permettant ensemble la détection du contour d'une image.

Maintenant, je souhaite détecter le contour d'une image dans l'une de méthodes d'une autre classe "Quantif.cpp".

Est-il possible de faire l'appel de tous les traitements d'une classe ensemble?

J'ai l'habitude de faire l'appel d'une seule méthode mais je ne sais pas comment le faire pour toute une classe!!!

Avez-vous une idée?

Merci d'avance.

[koala01]

Salut,

Aussi longtemps que:

1. 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
2. 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 :

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
 
/* 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:

1. 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
2. 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 :

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

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 :

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
/* 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 :

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

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 :

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
// 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