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

[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.

[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*) {}

[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"