Discussion :

[Tarrke]

Bonjour à tous,

je me posaisune question d'un point de vue C++ : est-il possible de rendre un accesseur transparent à l'utilisateur ?

En fait je voudrait pouvoir coder un truc de ce style :

Code :

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

1
2
3
4
5
6
7
8
class A {
private:
int unePropriete;
// autres déclarations
public:
const int& unePropriete() const { return uneProriete; }
// bla bla
};

et enfin plus loin :

Code :

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

1
2
3
4
A monA;
// traitements
if( A.unePropriete == valeur )
// etc...

et alors rendre le passage par l'accesseur totalement transparent pour l'utilisateur sans qu'il ait à écrire le jeu de "()" à la fin de l'appel de la fonction. il me semble que Delphi permet de faire de telles choses et je voulais donc savoir si c'était possible avec les compilo C++ et ce malgrès les problèmes que cela peut poser (confusion possible entre la donnée et l'accesseur dans les portions de codes où la donnée est accessible...)

Merci
Tarrke

[la drogue c'est mal]

non

ce qui pourrait ressembler le plus, c'est de faire un truc dégueux mais syntaxiquement juste (sur VC en tout cas):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
 
class A { 
private: 
int unePropriete; 
// autres déclarations 
public: 
 
#define Propriete unePropriete()
const int& unePropriete() const { return uneProriete; } 
// bla bla 
};

Code :

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

1
2
3
4
5
6
 
Code: 
A monA; 
// traitements 
if( A.Propriete == valeur ) 
// etc...

[Laurent Gomila]

S'il s'agit d'un accès en lecture et en écriture alors tu peux simplement virer les accesseurs et rendre ta donnée publique ; sinon je ne pense pas que tu puisses faire une telle chose.

Ou alors peut-être quelque chose de ce genre, mais c'est un peu tordu :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class A
{
public :
 
    A() : Propriete(unePropriete) {}
 
    const int& Propriete;
 
private :
 
    int unePropriete;
};

[Tarrke]

Salut et merci à vous deux pour vos réponses :
@loulou : en fait le principe est de protéger les données tout en facilitant leur accès sans avoir à utiliser des couple de parenthèses à tout bout de champs. Ceci permetterait à mon avis de facilité à la fois la lecture et l'écriture de code utilisant des tests sur des attributs.

@la drogue c'est mal : merci car ta réponse est clair et précise. Pourtant faire ce que tu suggère, bien que syntaxiquement correct, me semble être un peu lourd à géré, enfin pour filer du code simple à utiliser j'y penserais sûrement. Merci beaucoup pour ta réponse rapide.

[Luc Hermitte]

La solution type est de définir un proxy qui sera instancié comme une donnée membre publique de la classe, et qui référencera la donnée privée contenant l'état de la propriété.

Cela peut ressembler assez à la solution de Loulou24, sauf que l'on va définir un opérateur de convertion. Si on maitrise le type stocké, il peut être préférable de définir un constructeur d'initialisation à partir d'un proxy.
Reste que c'est très imparfait, on ne peut pas retrouver tous les aspects usuels, des sémantiques des types enveloppés, et que l'on peut attendre d'une propriété comme ce que l'on a parfois en propriétaire, avec certains outils/compilos.

De temps à autres, surgissent sur news:comp.lang.c++.moderated ou dans la zone fichiers de la ML de boost (sur yahoogroups) des propositions plus ou moins génériques d'implémentation. Il y a toujours un moyen d'y trouver à redire.

[julien.sagnard]

Ta solution m'intéresse, mais je n'ai pas réussit à trouver d'exemples sur le net. Donc j'ai essayé d'écrire un morceau de code d'après ce que j'ai compris.
Est ce que tu parlais de ç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
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
 
#include <iostream>
using namespace std;
 
class A;
class _AccessI{
   public :
      _AccessI();
      void setA( A * a );
      operator int (void) const;
      int operator=( int i );
   private :
      A * _a;
   };
 
 
class A{
   public :
      A() : _i(0) {
         i.setA( this );
         };
 
      int getI() const{
         return _i;
         };
 
      void setI( int i ){
         _i = i;
         };
 
      _AccessI i;
   private :
      int _i;
   };
 
_AccessI::_AccessI() : _a(NULL){
   }
 
_AccessI::operator int (void) const {
   return _a->getI();
   }
 
int _AccessI::operator=( int i ){
  _a->setI( i );
   return _a->getI();
   }
 
void _AccessI::setA( A * a ){
   _a = a;
   }
 
int main(){
   A a;
   cout << "a.i = " << a.i << endl;
   a.i = 4;
   cout << "a.i = " << a.i << endl;
   return 0;
   }

[Luc Hermitte]

J'aurais fait les choses différemment, mais c'est le principe.

Pour ce qui est des recherches, j'avais pourtant donné des indications plutôt bien ciblées
clc++m -> property
Pour boost par contre, google n'a pas l'air d'être très efficace. Je te conseille donc de récupérer un bon lecteur de news (si ce n'est déjà fait -- xnews n'est pas trop mal sous windows) et d'aller sur news://news.gmane.org/gmane.comp.lib.boost.devel/, et puis taper dans la barre de recherche : "property". Et là, tu auras du concentré de bonnes lectures sur le sujet. Entres autres: des liens vers http://lists.boost.org/Archives/boost/2004/11/75314.php, qui parle du n1615 (pdf sur le site du commité de standardisation)

Sinon de la lecture intéressante dans More Effective C++ de Scott Meyers, chez Addisson Wesley (comme d'hab), et il me semble avoir lu des points liés dans les Effective C++ d'Herb Sutter (toujours chez AW, et dont la forme pré-publication est en ligne sur GOTW).

Voilà, voilà. Bonnes lectures.