Impossible de limiter friend à une fonction

Version imprimable

03/08/2006, 12h11
NicolasJolet

Impossible de limiter friend à une fonction
Bonjour à tous,
J'ai une erreur avec le compilateur de VS2005, voici le shcéma :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Fille; class Mere { friend void Fille::Fonction(); // <-- Erreur C2027: use of undefined type }; class Fille : public Mere { public: void Fonction(){} };
Comment régler ce problème?

Merci d'avance,
Nicolas
03/08/2006, 12h16
boromir73

Tu as entendu parler de protected ?

Heu... Je viens de relire et en fait je ne vois pas pourquoi tu veux qu'une classe fille ne puisse accéder à la classe mère que par une fonction.
03/08/2006, 12h29
Eusebe

Je ne crois pas que tu puisse utiliser friend avec une fonction d'une classe fille.

Il faut en effet que la fonction soit définie avant d'utiliser friend. Pour ça, il faudrait définir la classe fille avant la classe Mère. Mais si la classe Fille hérite de Mère, Mère doit être définie avant Fille. Il y a une inclusion cyclique qui me parait impossible à résoudre.

Mais bon, est-tu sûr qu'utiliser friend est une bonne solution ?

Le design de mes classes n'est peut-être pas bon mais pour l'instant je préfère ne pas le changer.
Pour mettre un exemple plus concret (les classes sont bien sur incomplètes) :
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 30 31 32 33 class Control; class Window { friend void Control::Anchor(int set); // Pour pouvoir ajouter des listeners private: void AddListeners(Control &set); protected: HWND _hWnd; public: void Text(string set); ... }; class Control : public Window { public: void Anchor(int set) { ... wndParent.AddListeners(*this); } }; class Button : public Control { ... };
Pour pouvoir créer une propriété Anchor pour la classe Control, je dois enregistrer une liste de Control dans la fenêtre parente (qui va parcourir la liste lors d'un WM_SIZE).
Mais je n'ai pas envie de mettre la methode AddListeners en public car elle ne doit pas être utilisable par l'utilisateur qui utiliserait la classe Window.
Si je la met en protected et que je dérive en public, les classes héritants de Control, comme Button, auront accès à AddListeners, ce qui ne convient pas.
Si je la met en protected et que je dérive en protected ou private, les utilisateurs finaux n'auront plus accès aux méthodes publiques de Window, comme ici la méthode Text.

Est-ce que quelque chose comme ça te conviendrait :

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
 
class Mere
{
public:
	void f1() {}
};
 
class Mere_: virtual public Mere {
public:
	void f2() {}
};
 
class Fille1 : virtual public Mere, private Mere_ {
public:
  void g1() { f2(); }
};
 
class Fille2 : public Fille1 {
public:
  void g2() {
		//f2(); // inaccessible
		f1();
	}
};

03/08/2006, 13h04
NicolasJolet

Wow, je n'ai encore jamais dérivé une classe en virtual, je ne savais mm pas qu'il y avait moyen :?

Il semblerait que ca puisse convenir à mon cas, par contre je n'ai aucune idée de ce que donne une classe dérivée en virtual ...
03/08/2006, 13h08
boromir73

Autre solution plus simple : ta fonction friend ne doit pas être une fonction membre mais une fonction dont la déclaration n'est accessible qu'aux classes Mère et Fille1 (#include "fonctionfriend.h" dans "Mere.cpp" et "Fille1.cpp").
03/08/2006, 13h23
NicolasJolet
Même si elle a l'air moins propre (quoique ca depend pour qui ;)) je pense que la 2ème solution va me convenir.

Sinon il y a aussi comme possibilité :
- Déclarer toute la classe Fille en friend
- Créer une classe avant la classe Mere qui être friend de Mere et qui sera utilisée par la classe Fille.
Merci à tous,
Je pense que je vais utiliser la fonction dont la déclaration n'est accessible qu'aux classes Mere et Fille
03/08/2006, 13h30
boromir73
Juste pour info, il est possible de déclarer une classe fille avec une fonction friend de la classe mère :
Code:

1 2 3 4 5 6 7 8 9 10 template<typename T> struct Mere { void f() {} friend void T::g(); }; struct Fille : public Mere<Fille> { void g() {} };
Problème : le compilateur ne peut pas compiler g() si elle accède à Mère :(

Peut-être ceci est-il plus raisonnable :

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
30
 
class Mere {
public:
	void f1() {}
};
 
class MereInterface {
public:
	MereInterface(Mere& mere): mere(mere) {}
	void f2() {
		mere.f1();
	}
private:
	Mere& mere;
};
 
class Fille1: public MereInterface, private Mere {
public:
	Fille1(): MereInterface(*static_cast<Mere *>(this)) {}
	void f3() { f1(); }
};
 
class Fille2: public Fille1 {
public:
	void f4() {
		//f1(); // inaccessible
		//mere.f1(); // inaccessible
		f2();
	}
};

03/08/2006, 14h31
NicolasJolet

Je dois t'avouer que j'ai du mal à saisir toute la structure :?
Enfin je regarderai ca a tête reposée.

Merci pour ton aide :)
03/08/2006, 14h36
loufoque

Citation:

Fille1(): MereInterface(*static_cast<Mere *>(this)) {}

Les casts c'est suffisamment mal pour qu'on évite d'en mettre quand on n'en a pas besoin

Code:

Fille1(): MereInterface(*this) {}
03/08/2006, 14h40
boromir73

Citation:

Envoyé par loufoque

Les casts c'est suffisamment mal pour qu'on évite d'en mettre quand on n'en a pas besoin

Code:

Fille1(): MereInterface(*this) {}

Mon compilateur n'est pas d'accord, mais j'ai g++ 3.4.2 ; peut-être est-ce différent avec les nouvelles versions ?
03/08/2006, 14h43
loufoque

Le constructeur de MereInterface veut un Mere&, *this est un Fille1 qui hérite de Mere alors il me semble que cela devrait être converti de manière implicite.
03/08/2006, 14h50
boromir73

Il y a une ambiguité entre MereInterface(Mere&) et MereInterface(const MereInterface&), ce dernier étant le constructeur de copie implicite (ISO 12.8.4).
03/08/2006, 15h42
loufoque

Ah oui en effet.