Héritage et interfaces

Version imprimable

Bonjour,

Je voudrais savoir s'il existe un moyen de faire ça, avec la syntaxe du C++, sans passer par un design pattern ou autre architecture, juste du langage :

- Avoir une interface "interfaceI"
- Avoir une classe "classeA" qui implemente "interfaceI"

Et que "interfaceI" puisse acceder aux membres de "classeA", puisque "interfaceI" sera toujours utilisée avec "classeA"

Par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class classeA : public interfaceI { public: int varA; public: void uneMethode(); } interface interfaceI { public: void uneMethodeInterface(); }
et surtout :
Code:

1 2 3 4 interfaceI::uneMethodeInterface() { classeA::varA = 10; }
Comme solution, j'ai trouvé :

Passer la variable A à la fonction de l'interface :
Code:

1 2 3 4 5 interface interfaceI { public: void uneMethodeInterface(int& varA); }
Je me demandais surtout si y'a pas moyen de jouer avec les relations d'amitiés ou un truc du genre...

Merci.

Une interface n'a pas besoin d'accéder aux membres de la classe qui l'implémente, puisque toutes ses fonctions membres sont virtuelles pures (méthodes abstraites).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 class interfaceI //Il n'y a pas de mot "interface" en C++ standard { public: virtual void uneMethodeInterface() = 0; }; class classeA : public interfaceI { public: int varA; public: void uneMethode(); //Methodes d'interface interfaceI public: void uneMethodeInterface(); }; void classeA::uneMethodeInterface() { varA = 42; }

23/10/2007, 10h51
buzzkaido

Ah, oui, évidemment, je fais un abus de langage...

Il ne s'agit pas d'une interface, mais d'une classe utilisée comme telle, afin d'implémenter un comportement par défaut de l'interface.

La façon réélement propre de proceder est surement un pattern Decorator, mais là, y'a pas moyen (je reprend du code existant)

Dans ce cas, je procéderais ainsi:

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
class AUneInterfaceImpl : public IUneInterface
{
public:
	//Override, declared pure virtual in IUneInterface
	void uneMethodeInterface();
protected:
	virtual int & GetA() = 0;
};
 
class CUneClasse : public AUneInterfaceImpl
{
private:
	int varA;
protected:
	//Override, declared pure virtual in AUneInterfaceImpl
	int & GetA();
};
 
//Override, declared pure virtual in IUneInterface
void AUneInterfaceImpl::uneMethodeInterface()
{
	GetA() = 42;
}
 
//Override, declared pure virtual in AUneInterfaceImpl
int & CUneClasse::GetA()
{
	return varA;
}

Bien sûr, dans le cas présent, on peut sûrement aussi remplacer le GetA() virtuel par du CRTP.

Pour preciser, je souhaiterais ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class interfaceI
{
public:
	virtual void uneMethodeInterface();
};
 
void interfaceI::uneMethodeInterface()
{
	varA = 42;   // mettre varA en friend ? ou y'a pas moyen ?
}
 
class classeA : public interfaceI
{
public:
	int    varA;
 
public:
	void uneMethode();
 
};

Le code en CRTP:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
template< class Deriv >
class AUneInterfaceImpl : public IUneInterface
{
public:
	//Override, declared pure virtual in IUneInterface
	void uneMethodeInterface();
};
 
class CUneClasse : public AUneInterfaceImpl< CUneClasse >
{
public:
	int varA;
};
 
//Override, declared pure virtual in IUneInterface
template< class Deriv >
void AUneInterfaceImpl< Deriv >::uneMethodeInterface()
{
	Deriv * pDeriv = static_cast< Deriv * >(this);
	pDeriv->varA = 42;
}

23/10/2007, 11h03
Médinoc

PS: Ce n'est pas une question d'accès (friend ou public ou private), c'est une question de connaissance. Ta classe abstraite doit savoir que la classe dérivée possède une variable nommée varA.
Et ce, quelle que fut la classe dérivée.

Ou bien, il reste la solution la plus logique, qui est de déplacer la variable varA vers la classe de base.
23/10/2007, 11h07
buzzkaido

Citation:

Ce n'est pas une question d'accès (friend ou public ou private), c'est une question de connaissance.

Parfaitement.

Je ne connais pas très bien l'utilisation de Friend, je me demandais si le fait de rendre classeA amie de interfaceI ne rendait visible les variables membres de classeA à interfaceI.

Le CRTP, je connaissais pas, ça à l'air pas mal, mais je vais voir si je peux pas les convaincre de réécrire une partie du code pour éviter ce genre de choses...

Merci.
23/10/2007, 11h10
Médinoc

Citation:

Envoyé par buzzkaido

Parfaitement.

Je ne connais pas très bien l'utilisation de Friend, je me demandais si le fait de rendre classeA amie de interfaceI ne rendait visible les variables membres de classeA à interfaceI.

Ça les rend accessibles comme s'ils étaient public, mais ce n'est pas ça qui va permette à une interfaceI de savoir qu'elle est en réalité une classeA (et non pas n'importe quoi d'autre qui implémente l'interface).

Le CRTP, c'est comme du virtual, mais en statique au lieu d'être dynamique.
Mon exemple combine CRTP et virtualité: La classe abstraite template implémente l'interface commune.
23/10/2007, 16h59
NiamorH
En fait tu aimerais une classe de base qui agirait sur les membres de la classe qui en dérive.

Je ferais plutôt l'inverse, c-a-d :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class A { protected: int varA; }; template <class T> class Interface : public T { void Method() { T::varA = 10; } }; typedef Interface<A> AFinal;
C'est inspiré des classes de Politique.
23/10/2007, 17h02
buzzkaido

Ben oui, je ferais ça aussi...

Mais la classe de base est déjà écrite... et j'ai pas encore convaincu mon chef que ça vaut le coup de la ré-écrire pour faire un truc plus propre...