Discussion :

[buzzkaido]

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 :

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

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 :

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

1
2
3
4
interfaceI::uneMethodeInterface()
{
    classeA::varA = 10;
}

Comme solution, j'ai trouvé :

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

Code :

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

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.

[Médinoc]

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 C++ :

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
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;
}

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

[Médinoc]

Dans ce cas, je procéderais ainsi:

Code C++ :

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

[buzzkaido]

Pour preciser, je souhaiterais ceci :

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
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();
 
};

[Médinoc]

Le code en CRTP:

Code C++ :

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
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;
}

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

[buzzkaido]

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.

[Médinoc]

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.

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

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

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