Bonjour,

j'ai un problème avec une déclaration anticipée d'une classe dans le header d'une autre classe. Je m'explique:

J'ai une classe abonné :
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
//---------- Interface de la classe <Abonne> (fichier Abonne.h) ------
#if ! defined ( ABONNE_H_ )
#define ABONNE_H_
 
//--------------------------------------------------- Interfaces utilisées
 
#include <string>
using namespace std;
 
//------------------------------------------------------------- Constantes
 
//------------------------------------------------------------------ Types
class Annuaire;
 
typedef struct Renseignements{
	string prenom;
	string adresse;
	string telephone;
	Renseignements(string pren="",string adr="",string tel=""):prenom(pren),adresse(adr),telephone(tel){};
};
 
 
 
//------------------------------------------------------------------------
// Role de la classe <Abonne>
//
//
//------------------------------------------------------------------------
 
class Abonne
{
//----------------------------------------------------------------- PUBLIC
 
public:
//----------------------------------------------------- Méthodes publiques
    // type Méthode ( liste des paramètres );
    // Mode d'emploi :
    //
    // Contrat :
    //
 
	friend void Annuaire::Ajouter(Abonne e);
 
//------------------------------------------------- Surcharge d'opérateurs
    Abonne & operator = ( const Abonne & unAbonne );
    // Mode d'emploi :
    //
    // Contrat :
    //
 
    friend ostream & operator<<(ostream & flot,const Abonne & unAbonne);
    friend istream & operator>>(istream & flot,Abonne & unAbonne);
 
 
//-------------------------------------------- Constructeurs - destructeur
    Abonne ( const Abonne & unAbonne );
    // Mode d'emploi (constructeur de copie) :
    //
    // Contrat :
    //
 
    Abonne (string aNom="" , string aPrenom="", string aAdresse="", string aTel="" ):nom(aNom),info(aPrenom,aAdresse,aTel){};
    // Mode d'emploi :
    //
    // Contrat :
    //
 
    virtual ~Abonne ( );
    // Mode d'emploi :
    //
    // Contrat :
    //
 
//------------------------------------------------------------------ PRIVE
 
protected:
//----------------------------------------------------- Méthodes protégées
 
//----------------------------------------------------- Attributs protégés
	string nom;
	Renseignements info;
 
};
 
//--------------------------- Autres définitions dépendantes de <Abonne>
 
#endif // ABONNE_H_
et une classe annuaire pour gérer une collection d'abonnés avec une multimap.
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
//---------- Interface de la classe <Annuaire> (fichier Annuaire.h) ------
#if ! defined ( ANNUAIRE_H_ )
#define ANNUAIRE_H_
 
//--------------------------------------------------- Interfaces utilisées
#include "Abonne.h"
#include <map>
 
//------------------------------------------------------------- Constantes
 
//------------------------------------------------------------------ Types
 
//------------------------------------------------------------------------
// Role de la classe <Annuaire>
//
//
//------------------------------------------------------------------------
 
class Annuaire
{
//----------------------------------------------------------------- PUBLIC
 
public:
//----------------------------------------------------- Méthodes publiques
    // type Méthode ( liste des paramètres );
    // Mode d'emploi :
    //
    // Contrat :
    //
 
	void Ajouter(Abonne e);
 
	void Afficher() const;
 
 
//------------------------------------------------- Surcharge d'opérateurs
    Annuaire & operator = ( const Annuaire & unAnnuaire );
    // Mode d'emploi :
    //
    // Contrat :
    //
 
 
//-------------------------------------------- Constructeurs - destructeur
    Annuaire ( const Annuaire & unAnnuaire );
    // Mode d'emploi (constructeur de copie) :
    //
    // Contrat :
    //
 
    Annuaire ( );
    // Mode d'emploi :
    //
    // Contrat :
    //
 
    virtual ~Annuaire ( );
    // Mode d'emploi :
    //
    // Contrat :
    //
 
//------------------------------------------------------------------ PRIVE
 
protected:
//----------------------------------------------------- Méthodes protégées
 
//----------------------------------------------------- Attributs protégés
	multimap<string,Renseignements> pagesBlanches;
 
};
 
//--------------------------- Autres définitions dépendantes de <Annuaire>
 
#endif // ANNUAIRE_H_
Le souci se pose au niveau de la fonction Ajouter() de la classe annuaire. Je souhaite ajouter un abonné à l'annuaire. J'ai pour cela défini comme ami la fonction Annuaire::Ajouter dans la classe Abonne. Pour rendre cela possible je souhaite utiliser une déclaration anticipée de la classe Annuaire dans la classe Abonne.

Mais voilà à la compilation cela ne passe pas :

forward declaration of «struct Annuaire» Abonne.h Annuaire 20
invalid use of incomplete type «struct Annuaire» Abonne.h Annuaire 49

quelqu'un a une idée?

merci