donnée membre constante à l'extérieur de la class

**onap** · 08/11/2004, 14h54

Bonjour à tous,
est-il possible d'avoir une donnée membre d'une class déclarée dans la partie public, modifiable par les fonctions membres et qui serait seulement accessible en lecture seule (non modifiable) à l'extérieur de la class, du style:

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
 
class point {
   public:
   int var;
   void modvar(int);
};
point::modvar(int y)
{
var=y.2;
}
//-----------------------------------------------------------------------------
int main()
{
point pt;
int z=pt.var;   // acces en lecture
pt.var=2;             // refusé 
}

Cela pour évité de déclarer ma variable en private et fournir sa valeur par une fonction membre.

Merci

**onap** · 08/11/2004, 15h08

Merci de ta réponse mais comme je l'ai signalé:

Cela pour évité de déclarer ma variable en private et fournir sa valeur par une fonction membre.

je ne voudrais pas utiliser cette méthode.

**Aurelien.Regat-Barrel** · 08/11/2004, 15h16

La méthode propre c'est de mettre var en protected/private et de fournir un accesseur. Pourquoi ne veux-tu pas procéder ainsi ? Le reste c'est de la vilaine bidouille, et c'est sans garantie.

**onap** · 08/11/2004, 15h26

Je t'avoue que j'ai procédé de cette manière (accès par accesseur), ma question était plus par curiosité/compréhension que un problème à résoudre.
Merci de ta réponse.

**Aurelien.Regat-Barrel** · 08/11/2004, 15h36

Bon ben si c'est par curiosité tu peux faire ç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
class Point
{ 
public: 
    Point() : var( 10 ) {} // nécessaire...
    const int var; // lecture seule, enfin, normalement...
 
    void set_var( int Val ) // cast barbare pour modifier...
    {
        static_cast<int>( this->var ) = Val;
    }
}; 
 
int main()
{
    Point p;
    p.set_var( 15 ); // ok
    // sauf que on peut le faire ici aussi le cast...
    static_cast<int>( p.var ) = 20;
    cout << p.var << '\n';;
}

Mais si tu as le mutator, naturellement on s'attend à l'accesseur. Et comme tu peux le voir, le const dérange, mais n'empêche pas de modifier.

**Luc Hermitte** · 08/11/2004, 15h57

En exportant un proxy ?
Code vite pondu et vite testé:

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>
 
template <typename T>
struct RO_proxy
{
    operator const T() const { return v_; }
    RO_proxy(T const& v) : v_(v) {}
private:
    T const & v_;
};
 
struct toto
{
    toto() : entier_(0), entier(entier_) {}
    void next() { ++entier_; }
 
private:
    int           entier_;
public:
    RO_proxy<int> entier;
};
 
int main (int argc, char **argv)
{
    toto t;
 
    std::cout << t.entier << std::endl;
    t.next();
    std::cout << t.entier << std::endl;
 
    // t.entier = 2;
    // est interdit car on ne peut copier des RO_proxy entre eux...
    // 2 est implicitement converti en RO_proxy, mais ces derniers
    // ne sont pas assignables => refusé
 
    int i = 41;
    RO_proxy<int> p = i;
    ++i;
    std::cout << p << std::endl;
    // p = 12;
    i = t.entier;
    std::cout << p << std::endl;
 
    // p = t.entier; 
    // est interdit car on utilise une référence => non assignable
 
    RO_proxy<int> q = t.entier;
    t.next();
    std::cout << q << std::endl;
 
    // Aussi inutile que cela puisse être, ceci est accepté
    // J'ai quand même un doute quant à sa validité.
    RO_proxy<int> r = 2;
    std::cout << r << std::endl;
 
    std::cout << std::endl;
    return 0;
}
// Vim: let $CXXFLAGS='-Wall -pedantic'

Il est toujours possible de se rajouter des assertions statiques (voir Modern C++ Design/Loki ou boost) si les messages d'erreurs paraissent trop obscurs.

PS: Aurélien, ne voulais-tu pas utiliser const_cast<> plutôt ?

NB: divers edits