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