bangrazi@ctron.com (Anthony Bangrazi) (06/14/91)
Could someone please help me? I want to allow read-only access to private
data members, without having a method to return the value (thus avoiding the
parenthesis).
****************************
class Z {
public:
const int& z = &zP;
private:
int zP;
}
int main ()
{
Z* myZ = new Z;
printf ("%d\n", myZ.z);
delete myZ;
}
****************************
Note no parenthesis on "myZ.z"
Also, since z is "const", one cannot "myZ.z = 4"
Thanks for an help.
Anthony Bangrazi
bangrazi@ctron.commmk@d62iwa.mitre.org (Morris M. Keesan) (06/14/91)
In article <1654@balrog.ctron.com> bangrazi@ctron.com (Anthony Bangrazi) writes: >Could someone please help me? I want to allow read-only access to private >data members, without having a method to return the value (thus avoiding the >parenthesis). > > class Z { > public: > const int& z = &zP; > private: > int zP; > } > > int main () > { > Z* myZ = new Z; > printf ("%d\n", myZ.z); > delete myZ; > } > > **************************** > > Note no parenthesis on "myZ.z" > Also, since z is "const", one cannot "myZ.z = 4" Here's one way to write C++ which doesn't look like C++ (why else want to avoid the parentheses?), and without the need for extra data members: class Z { private: int zP; public: int zpub(void) { return zP; } } #define z zpub() int main() { Z* myZ = new Z; printf ("%d\n", myZ.z); delete myZ; } Note no parentheses, myZ.z is not an lvalue, and we haven't used an extra data member. But what's wrong with printf("%d\n", myZ.z()); ? (Assuming no #define, and z in place of zpub, above) I think it looks more like C++, and will cause less confusion for other people reading your code, who would otherwise being saying to themselves, "Why didn't he just write an inline member function to retrieve this value?" or "What's the purpose of this silly macro?" -------------------------------------------------------------- Morris M. Keesan, temporarily mmk@d62iwa.mitre.org
budd@fog.CS.ORST.EDU (Tim Budd) (06/14/91)
In article <1654@balrog.ctron.com> bangrazi@ctron.com writes: > >**************************** > >class Z { >public: > const int& z = &zP; >private: > int zP; >} > >int main () >{ > Z* myZ = new Z; > printf ("%d\n", myZ.z); > delete myZ; >} > >**************************** > This is a neat trick. I like it. But I think some of the details are wrong (at least they don't work as planned using GNU 1.37). The declaration needs to be int& const (reference to a constant), not const int & (constant reference). Also G++ doesn't like the constant assignment as shown, but will allow me to put it in the constructor. Here is the example fixed up (at least it works on MY machine). class Z { public: int& const z; Z() : z(zP) { zP = 12; } modifier() { /* methods can modify zP */ zP += 7; } private: int zP; }; int main () { Z* myZ = new Z; printf("%d\n", myZ->z); myZ->modifier(); // myZ->z = 24; will generate an error printf("%d\n", myZ->z); }
sra@ecs.soton.ac.uk (Stephen Adams) (06/14/91)
In article <1654@balrog.ctron.com> bangrazi@ctron.com writes: [A neat trick using references to give parenthesis free access to controlled member] In article <1991Jun13.211926.20276@lynx.CS.ORST.EDU> budd@fog.CS.ORST.EDU (Tim Budd) writes: > This is a neat trick. I like it. But I think some of the details are > wrong (at least they don't work as planned using GNU 1.37). The declaration > needs to be int& const (reference to a constant), not const int & (constant > reference). Also G++ doesn't like the constant assignment as shown, but > will allow me to put it in the constructor. > > Here is the example fixed up (at least it works on MY machine). > > class Z { > public: > int& const z; > Z() : z(zP) { zP = 12; } > > modifier() { /* methods can modify zP */ zP += 7; } > private: > int zP; > }; > At first I thought that it was a nice idea. Now I am not so sure. There are problems: 1. The copy constructor must also initialize z in this way (easily forgotten). If it does not, z in the copy will refer to zP in the original object. It might take a lifetime to figure out a bug like that. 2. An assignment operator is equally tricky: it can't be the bitwise for the same reasons as (1). Assignment has to copy everything else by hand. (The destination object has already had the references set up by its constructor.) 3. For various reasons like the above, in the general case the reference has to be stored as a pointer. In this example this doubles the size of the object (so might halve the speed of the program). In view of these disappointments I think that I will stick with the `.z()' syntax. I am used to parentheses - I used to be a lisp programmer :-) A revised definition is: class Z { public: int& const z; Z() : z(zP) { zP = 12; } Z(Z& other) : z(zP) { zP=other.zP; } void operator = (Z& other) { zP=other.zP; } modifier() { /* methods can modify zP */ zP += 7; } private: int zP; }; -- Stephen Adams S.R.Adams@ecs.soton.ac.uk Computer Science University of Southampton Southampton SO9 5NH, UK
rae@alias.com (Reid Ellis) (06/17/91)
Tim Budd <budd@fog.CS.ORST.EDU> writes: |...I think some of the details are wrong (at least they don't work as |planned using GNU 1.37). The declaration needs to be int& const |(reference to a constant), not const int & (constant reference). Stephen Adams <sra@ecs.soton.ac.uk> writes: | class Z { | public: | int& const z; ... | }; The "const" goes in *front* of the "int". What you're defining is a constant reference to an int [a bit redundant, that] rather than a reference to a constant int, which would be more like "const int &z". See the ARM, section 8.4.3 on p 154, about halfway down. Reid -- Reid Ellis _|\ |V| /|_ rae@utcs.toronto.edu || rae@alias.com \ \| |/ / CDA0610@applelink.apple.com || +1 416 362 9181 [work] >_______< !