Discussion :

[BugFactory]

Bonjour,

Adepte du Java depuis déjà quelques années, je me suis remis au C++ récement pour ne pas perdre la main. Et c'est dur.

Je me demandais comment faire quand deux classes appellent chacune un traitement de l'autre, lequel traitement est une fonction inline.

Prenons la situation suivante.
J'ai deux classes, appellons les A et B.
Chacune de ces classes dispose d'une méthode qui reçoit un objet de l'autre classe en argument, et utilise une autre méthode de cette dernière.

Ca donne:

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
 
class B;
 
class A
{
public:
    // Méthode de A utilisant B::traitementB
    void traitementAUtilisantB(B objetB);
 
    // Méthode de A utilisée par B::traitementBUtilisantA
    void traitementA(void);
 
    // Diverses autres méthodes et attributs
}
 
class B
{
public:
    // Méthode de B utilisant A::traitementA
    void traitementBUtilisantA(A objetA);
 
    // Méthode de B utilisée par A::traitementAUtilisantB
    void traitementB(void);
 
    // Diverses autres méthodes et attributs
}

Jusqu'ici, pas de problème.

Mais ça se complique énormément si je décide que ces quatres méthodes (A::traitementA, B::traitementB, A::traitementAUtilisantB et B::traitementBUtilisantA) doivent être des fonctions inline.
En effet, comme le compilateur remplace une fonction inline par son code partout où c'est possible, une fonction inline doit être déclarée et définie au même endroit. Sauf erreur, pas question donc de placer leur code dans un fichier cpp après avoir déclaré ces deux classes. Il faut que le code des fonctions se trouve dans la déclaration de la classe.
Or, A::traitementAUtilisantB fait appel à B::traitementB. Il faut donc que la déclaration de B::traitementB soit avant la définition de A::traitementAUtilisantB. Et donc s'agissant de fonctions inline et d'après ce qui précède, que la définition (et pas simplement la déclaration) de la classe B se trouve avant celle de la classe A.
Mais ce qui est vrai pour A::traitementAUtilisantB et B::traitementB l'est aussi pour B::traitementBUtilisantA et A::traitementA. Et donc A doit être avant B.
On a donc A doit être avant B et B doit être avant A. Ce qui est impossible.

Ma question est : ai-je commis une erreur où suis-je tombé sur une limitation du C++? Dans le second cas, comment la contourner (autrement quand laissant tomber les inline) ?

Pour information, je suis tombé sur ce cas de figure en essayant de créer deux classes Application et InputController. Et je sais que l'utilité d'inline est limité, mais il ne fallait pas me donner quelque chose et s'attendre à ce que je n'essaie pas de jouer avec...

Merci d'avance.

[NewbiZ]

* Tu peux déclarer une méthode inline en dehors de la classe, il suffit de lui préfixer "inline". Le fait que les méthodes implémentées dans le corps de la classe soient inline n'est qu'une commodité.

* Tu peux prédéclarer les classes

[Laurent Gomila]

Il vaut mieux bien sûr éviter l'inlining, surtout s'il ne sert à rien.

L'autre solution c'est de déclarer A et B dans le même en-tête :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class B;
 
class A
{
    void f(B*);
};
 
class B
{
    void f(A*);
};
 
inline void A::f(B*) {}
inline void B::f(A*) {}

[BugFactory]

En effet, je pourrais déclarer classe A et classe B puis déclarer et définir
A::traitementA, puis B::traitementB, puis A::traitementAUtilisantB et enfin B:: traitementBUtilisantA.
En revanche je vais être obligé de casser ma règle "un fichier .h par classe". Dommage.

Merci de m'avoir expliqué. Au revoir!

PS: oui, je sais que l'inlining est rarement utile. Mais je suis curieux.

[koala01]

Salut,

Tu peux tout à fait définir ta fonction directement dans le corps de la classe:

En reprenant ton exemple

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
 
class B;
 
class A
{
public:
    // Méthode de A utilisant B::traitementB
    void traitementAUtilisantB(B objetB)
    {
         //le mot clé "inline" est sous entendu
    }
 
    // Méthode de A utilisée par B::traitementBUtilisantA
    void traitementA(void)
    {
         //le mot clé "inline" est sous entendu
    }
 
    // Diverses autres méthodes et attributs
}
 
class B
{
public:
    // Méthode de B utilisant A::traitementA
    void traitementBUtilisantA(A objetA)
    {
         //le mot clé "inline" est sous entendu
    }
 
    // Méthode de B utilisée par A::traitementAUtilisantB
    void traitementB(void)
    {
         //le mot clé "inline" est sous entendu
    }
 
    // Diverses autres méthodes et attributs
}

Ou bien, mais c'est plus crade, définir tes méthodes dans un fichier "à part" en les faisant précéder du mot clé inline, et inclure ce fichier dans ceux qui doivent faire appel à ces méthodes

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
fichier.h
class B;
 
class A
{
public:
    // Méthode de A utilisant B::traitementB
    void traitementAUtilisantB(B objetB);
 
    // Méthode de A utilisée par B::traitementBUtilisantA
    void traitementA(void);
 
    // Diverses autres méthodes et attributs
};
 
class B
{
public:
    // Méthode de B utilisant A::traitementA
    void traitementBUtilisantA(A objetA);
 
    // Méthode de B utilisée par A::traitementAUtilisantB
    void traitementB(void);
 
    // Diverses autres méthodes et attributs
};

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
impl.cpp
#include "fichier.h"
inline void A::traitementAUtilisantB(B objetB)
{

}

inline void A::traitementA(void)
{

}
inline void B::traitementBUtilisantA(A objetA)
{

}
inline void B::traitementB(void)
{

}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
main.cpp
#include "impl.cpp"
int main()
{
    A a;
    B b;
    b.traitementBUtilisantA(a);
    b.traitementB();
    a.traitementAUtilisantB(b);
    a.traitementA();
    return 0;
}

et une solution alternative étant de les définir dans le fichier d'entete, en dessous des déclarations des classes, et précédées du mot clé inline...

Nota: reste attentif au fait qu'il faut un ; apres l'accolade fermant la déclaration de ta classe

[Laurent Gomila]

Pour le premier exemple, je ne vois pas comment la classe A va pouvoir utiliser un B avec une simple déclaration anticipée. C'est pour ça qu'il faut implémenter la fonction après la définition de la classe B.

Pour le second exemple, en général on évite .cpp comme extension, vu que ce sera compilé automatiquement à part si tu fais ton makefile à la main.

Et puis la méthode est mauvaise : on inclue le fichier (.tpl, .inl, comme tu veux mais pas .cpp) dans l'en-tête, pas l'inverse :

Code :

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

1
2
3
4
5
6
7
8
-- classe.h --

class Classe
{
    void f();
};

#include "Classe.inl"

Code :

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

1
2
3
4
5
6
-- classe.inl --

inline void Classe::f()
{

}

Code :

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

1
2
3
-- main.cpp --

#include "Classe.h"