Discussion :

[AL1986]

Salut,

Je dispose d'une classe Classe dont le code ressemble à ça

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
class Classe {
 
public:
	Classe(){};
	virtual ~Classe(){};
 
//quelques attributs private et des setters et getters public
 
private:
	bool _attribut;
public:
	const bool& getAttribut() {
		return _attribut;
	};
	void setAttribut(bool iAttribut) {
		_attribut = iAttribut;
	};	
};

J'aimerai permettre à une autre classe C1 d'appeler le getter mais pas le setter. Pour le getter, il n y a pas de problème, par contre le setter est appelé par une autre classe C2, c'est pour cela que je l'ai mis public. Par conséquent, je ne peux empêcher C1 de faire appel à ce setter. Comment devrai-je faire afin d'y lui interdire l'accès sachant que je n'ai aucun contrôle sur C1 ?
Merci pour votre aide.

[NewbiZ]

C'est un peu étrange comme conception...
Typiquement, tu ne peux pas connaitre l'appelant d'une méthode (dommage), il te reste donc à mon sens 2 possibilités :

1) Passer le setter en privé, et spécifier une amitié pour les classes pouvant appeler le setter. Problème: elles auront aussi accès aux autres fonctions privées.

2) Demander explicitement à l'appelant de s'identifier (enum ou pointeur sur son instance ou template), et surcharger le setter en conséquence. Problème: rien n'empeche que l'appelant tricher, et ca salit considérablement les appels.

3) Essayer de rendre la chose cachée, et utiliser l'héritage, encore une fois, c'est pas vraiment parfait, ca repose sur un topcast.

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
#include <iostream>
#include <cstdlib>
 
class Foo
{
public:
  Foo() : m_bar(0) {}
  virtual ~Foo()   {}
 
  const int& getBar() const    { return m_bar; }
 
protected:
  virtual void setBar( int bar ) { m_bar = bar;  }
 
private:
  int m_bar;
};
 
class FooUnsecured : public Foo
{
public:
  virtual void setBar( int bar ) { Foo::setBar(bar); }
};
 
class Trusted
{
public:
  void giveMeFoo( FooUnsecured* foo )
  {
    std::cout << "Trusted::giveMeFoo()" << std::endl;
    std::cout << "foo->getBar() = " << foo->getBar() << std::endl;
    foo->setBar( 10 );
    std::cout << "foo->getBar() = " << foo->getBar() << std::endl;
  }
};
 
class Untrusted
{
public:
  void giveMeFoo( Foo* foo )
  {
    std::cout << "Trusted::giveMeFoo()" << std::endl;
    std::cout << "foo->getBar() = " << foo->getBar() << std::endl;
    foo->setBar( 10 ); // Erreur
    std::cout << "foo->getBar() = " << foo->getBar() << std::endl;
  }
};
 
int main( int, char** )
{
  FooUnsecured* foo = new FooUnsecured();
  Untrusted untrusted;
  Trusted   trusted;
 
  untrusted.giveMeFoo( foo );
  trusted.giveMeFoo  ( foo );
 
  return EXIT_SUCCESS;
}

[Médinoc]

Ou bien, tout simplement rendre ta classe const-correcte :

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
class Classe {
 
public:
	Classe(){};
	virtual ~Classe(){};
	
//quelques attributs private et des setters et getters public
 
private:
	bool _attribut;
public:
	const bool& getAttribut() const {
		return _attribut;
	};
	void setAttribut(bool iAttribut) {
		_attribut = iAttribut;
	};	
};

Ainsi, il te suffit de passer un pointeur const Classe * à la classe dont tu ne veux pas qu'elle puisse appeller le setter...

[Emmanuel Deloget]

Autre solution: ne pas se prendre la tête avec ce genre de détails

Qui écrit C1 et C2 ? Si c'est toi, alors à priori il n'y a pas de problème. Si ce n'est pas toi, alors pourquoi interdire l'appel ?

[AL1986]

Merci pour vos réponses.

Autre solution: ne pas se prendre la tête avec ce genre de détails

Qui écrit C1 et C2 ? Si c'est toi, alors à priori il n'y a pas de problème. Si ce n'est pas toi, alors pourquoi interdire l'appel ?

C'est moi qui écrit C2. Par contre, C1 sera écrite par quelqu'un d'autre qu'on appelera client. J'aimerai permettre au client de ne "voir" que les données dont il a besoin. Il se trouve qu'il a besoin d'avoir accès à tous les éléments de Classe sauf le setter de _attribut.

[Mat007]

Salut,

J'aimerai permettre au client de ne "voir" que les données dont il a besoin. Il se trouve qu'il a besoin d'avoir accès à tous les éléments de Classe sauf le setter de _attribut.

Tu définis une interface (une classe avec que des méthodes virtuelles pures) C implémentée par C2 et tu passes C à C1 au lieu de C2.
Ça permet de contrôler précisément ce que C1 manipule tout en masquant complètement l'implémentation.

MAT.

[wakaa3lik]

salut

bon je sais pas si ca t'interesse mais jette un coup d'oeuil sur les fonction amis.

freind permet l'acces des fonctions aux attribus meme s'elles sont pas membres de la classe d ces attribus !



j'espere que j'ajoute qlqchose !

bone chance

[Alp]

Soit de la généricité (template) soit de l'héritage permettent de résoudre ton problème. Je préfère la méthode avec les templates.

[AL1986]

Merci pour vos réponses.

salut

bon je sais pas si ca t'interesse mais jette un coup d'oeuil sur les fonction amis.

freind permet l'acces des fonctions aux attribus meme s'elles sont pas membres de la classe d ces attribus !



j'espere que j'ajoute qlqchose !

bone chance

NewBiz m'a déjà proposé d'utiliser l'amitié mais cela donne aussi accès aux autres attributs privés.

1) Passer le setter en privé, et spécifier une amitié pour les classes pouvant appeler le setter. Problème: elles auront aussi accès aux autres fonctions privées.

Je pense que je vais opter pour l'une de ces deux solutions :

3) Essayer de rendre la chose cachée, et utiliser l'héritage, encore une fois, c'est pas vraiment parfait, ca repose sur un topcast.

Soit de la généricité (template) soit de l'héritage permettent de résoudre ton problème. Je préfère la méthode avec les templates.

Merci à tous.