The use of const reference instear of getter

[Turin]

Dear all;

As far as I understand the idea behind getter methods, it is used to
make sure that private memers of a class is returned appropriately to
the calling object.

However, if all I am interested in when making a member private is to
disallow the modification of the value of that member (read-only
member), then how about doing the following:

class A {
public :
const int& ref_to_priv_mem ber;
A() : ref_to_priv_mem ber(priv_member ) {
/* Blah */
}

private :
int private_member;
};

I would like to know the opinion of C++ experts on this and if there
are any side-effects of this.
Also from the perferformance point of view, isn't using this mor
effecient than using a getter?

Looking forwards to hearing your opinions.

[Pascal J. Bourguignon]

Turin <om*********@gm ail.comwrites:

Dear all;

As far as I understand the idea behind getter methods, it is used to
make sure that private memers of a class is returned appropriately to
the calling object.

However, if all I am interested in when making a member private is to
disallow the modification of the value of that member (read-only
member), then how about doing the following:
[...]
I would like to know the opinion of C++ experts on this and if there
are any side-effects of this.
Also from the perferformance point of view, isn't using this mor
effecient than using a getter?

Looking forwards to hearing your opinions.

class A {
public :
const int& ref_to_priv_mem ber;

Instead, do this:

inline int ref_to_priv_mem ber(void) const { return private_member; }

this way you have only a right-value, and if the implementation should
change, you won't have to change the client code (only recompile). On
the other hand, inline member functions will be optimized out and
you'll get the same code as with a data member.

--
__Pascal Bourguignon__

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2008-08-04 13:31, Turin wrote:

Dear all;

As far as I understand the idea behind getter methods, it is used to
make sure that private memers of a class is returned appropriately to
the calling object.

However, if all I am interested in when making a member private is to
disallow the modification of the value of that member (read-only
member), then how about doing the following:

class A {
public :
const int& ref_to_priv_mem ber;
A() : ref_to_priv_mem ber(priv_member ) {
/* Blah */
}

private :
int private_member;
};

I would like to know the opinion of C++ experts on this and if there
are any side-effects of this.
Also from the perferformance point of view, isn't using this mor
effecient than using a getter?

Any good compiler will probably reduce a getter function to the same
thing, with the exception that you can, if you want, easily make changes
to the getter function (such as changing the returned value is certain
cases).

--
Erik Wikström

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2008-08-04 13:42, Pascal J. Bourguignon wrote:

Turin <om*********@gm ail.comwrites:

>Dear all;

As far as I understand the idea behind getter methods, it is used to
make sure that private memers of a class is returned appropriately to
the calling object.

However, if all I am interested in when making a member private is to
disallow the modification of the value of that member (read-only
member), then how about doing the following:
[...]
I would like to know the opinion of C++ experts on this and if there
are any side-effects of this.
Also from the perferformance point of view, isn't using this mor
effecient than using a getter?

Looking forwards to hearing your opinions.

>class A {
public :
const int& ref_to_priv_mem ber;

Instead, do this:

inline int ref_to_priv_mem ber(void) const { return private_member; }

Nitpick:
inline is superfluous since the function is defined in the class
definition, and in C++ we usually write foo() and not foo(void), the
latter is considered bad style.

--
Erik Wikström

[AnonMail2005]

On Aug 4, 7:31*am, Turin <omar.ham...@gm ail.comwrote:

Dear all;

As far as I understand the idea behind getter methods, it is used to
make sure that private memers of a class is returned appropriately to
the calling object.

However, if all I am interested in when making a member private is to
disallow the modification of the value of that member (read-only
member), then how about doing the following:

class A {
* public :
* * const int& ref_to_priv_mem ber;
* * A() : ref_to_priv_mem ber(priv_member ) {
* * * /* Blah */
* * }

* private :
* * int private_member;

};

I would like to know the opinion of C++ experts on this and if there
are any side-effects of this.
Also from the perferformance point of view, isn't using this mor
effecient than using a getter?

Looking forwards to hearing your opinions.

I use the same rule of thumb in this case as I do to determine whether
I should pass an object by const reference to a function - built in
types get passed by value, all others get passed by const reference.

And, BTW, std::string is not a built in type ;).

HTH

[Jerry Coffin]

In article <7210b453-7a0e-4af3-a159-98f7848d28dd@
34g2000hsh.goog legroups.com>, om*********@gma il.com says...

[ ... ]

However, if all I am interested in when making a member private is to
disallow the modification of the value of that member (read-only
member), then how about doing the following:

class A {
public :
const int& ref_to_priv_mem ber;
A() : ref_to_priv_mem ber(priv_member ) {
/* Blah */
}

private :
int private_member;
};

I would like to know the opinion of C++ experts on this and if there
are any side-effects of this.
Also from the perferformance point of view, isn't using this mor
effecient than using a getter?

Looking forwards to hearing your opinions.

This works perfectly well, and doesn't really have any side-effects.

Contrary to the claims elsethread, there's also no real problem in the
(IME unlikely) event that you need to change what's returned -- instead
of using an (explicit) member function, you can create a small proxy
class something like this:

class A {

struct ref_to_priv_mem ber {
friend class A;
operator const int &() { return private_member; }
private:
int private_member;

};
};

Now, if you need to modify what ref_to_priv_mem ber returns, you can do
it in your operator, without any effect on external code.

This does have a couple of _minor_ side effects. First of all, since
only one user-defined operator will be considered in an implicit
conversion sequence, if you were depending on (for example) returning a
reference to constant int, and having that used to construct some other
object (implicitly) this would break the code. IMO, this is a positive
far more often than a negative -- on the rare occasion that such a
conversion is needed, you're probably better off making it explicit,
such as adding a conversion to the inner class that directly creates the
type you want (or adding a ctor to that type that constructs it directly
from this inner class). At the same time, this prevents such implicit
conversions from happening by accident, making the code substantially
safer.

Second, (and usually more importantly) this keeps you from having ugly
code everywhere on the off chance that some day it'll become useful to
have a member function to produce the desired value instead of allowing
"reading a value" to look like reading a value.

--
Later,
Jerry.

The universe is a figment of its own imagination.

[Pascal J. Bourguignon]

Erik Wikström <Er***********@ telia.comwrites :

On 2008-08-04 13:42, Pascal J. Bourguignon wrote:

>Turin <om*********@gm ail.comwrites:

>>Dear all;

As far as I understand the idea behind getter methods, it is used to
make sure that private memers of a class is returned appropriately to
the calling object.

However, if all I am interested in when making a member private is to
disallow the modification of the value of that member (read-only
member), then how about doing the following:
[...]
I would like to know the opinion of C++ experts on this and if there
are any side-effects of this.
Also from the perferformance point of view, isn't using this mor
effecient than using a getter?

Looking forwards to hearing your opinions.

>>class A {
public :
const int& ref_to_priv_mem ber;

Instead, do this:

inline int ref_to_priv_mem ber(void) const { return private_member; }

Nitpick:
inline is superfluous since the function is defined in the class
definition, and in C++ we usually write foo() and not foo(void), the
latter is considered bad style.

Why?

Is it because it reminds of the C ancestry?

Since I learned C first, I'm always afraid that with foo() it would
accept any number of arguments...

--
__Pascal Bourguignon__

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2008-08-04 15:54, Pascal J. Bourguignon wrote:

Erik Wikström <Er***********@ telia.comwrites :

>On 2008-08-04 13:42, Pascal J. Bourguignon wrote:

>>Turin <om*********@gm ail.comwrites:

Dear all;

As far as I understand the idea behind getter methods, it is used to
make sure that private memers of a class is returned appropriately to
the calling object.

However, if all I am interested in when making a member private is to
disallow the modification of the value of that member (read-only
member), then how about doing the following:
[...]
I would like to know the opinion of C++ experts on this and if there
are any side-effects of this.
Also from the perferformance point of view, isn't using this mor
effecient than using a getter?

Looking forwards to hearing your opinions.

class A {
public :
const int& ref_to_priv_mem ber;

Instead, do this:

inline int ref_to_priv_mem ber(void) const { return private_member; }

Nitpick:
inline is superfluous since the function is defined in the class
definition, and in C++ we usually write foo() and not foo(void), the
latter is considered bad style.

Why?

Is it because it reminds of the C ancestry?

Since I learned C first, I'm always afraid that with foo() it would
accept any number of arguments...

Well, for one it is inconsistent. If I write foo(bar) it means that foo
takes one argument of type bar, regardless if bar = void or not (in
other words foo(void) means foo takes one argument of type void). So for
me that means that the only way to call foo would be to somehow supply
an argument of type void.

--
Erik Wikström

[James Kanze]

On Aug 4, 3:52 pm, Jerry Coffin <jcof...@taeus. comwrote:

In article <7210b453-7a0e-4af3-a159-98f7848d28dd@
34g2000hsh.goog legroups.com>, omar.ham...@gma il.com says...

[ ... ]

However, if all I am interested in when making a member
private is to disallow the modification of the value of that
member (read-only member), then how about doing the
following:

class A {
public :
const int& ref_to_priv_mem ber;
A() : ref_to_priv_mem ber(priv_member ) {
/* Blah */
}

private :
int private_member;
};

I would like to know the opinion of C++ experts on this and
if there are any side-effects of this. Also from the
perferformance point of view, isn't using this more effecient
than using a getter?

Looking forwards to hearing your opinions.

This works perfectly well, and doesn't really have any
side-effects.

With most compilers, it will increase the size of the object.
(And since the original poster mentionned performance, I expect
that with most compilers, compared to a getter, it will generate
slower code. Internally, the reference will be implemented as a
pointer, and that ain't good for optimization.)

The other problem is consistency. When you need to return
something that isn't really a member variable, you use a
function call; for the member variable, you use a reference.
Isn't that exposing internal details which the client code
should not be concerned with?

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Juha Nieminen]

Turin wrote:

I would like to know the opinion of C++ experts on this and if there
are any side-effects of this.
Also from the perferformance point of view, isn't using this mor
effecient than using a getter?

You have got it completely backwards: Using such a member reference is
going to increase the size of the objects instantiated from the class
(which a member function won't do), it will make instantiating your
class slower (because the reference needs to be initialized) and
accessing the element will be slower (because the compiler will most
probably be unable to optimize the indirection away, as it has no way of
knowing at compile time where the reference is pointing to).

An inline member function will not increment the size of the class,
will have zero overhead at instantiation (and basically anything else),
and will have zero overhead to access the member variable (at least if
the compiler is optimizing).

If what you fear is that a member function will cause slow code,
inlining such a simple member function is one of the easiest
optimizations for any C++ compiler to do. (The only situation where it
will not inline it is when you have all optimizations turned off, eg.
for debugging purposes.)

From an object-oriented point of view your reference is also exposing
the internal implementation details of your class, which the getter
function isn't. (In other words, you could later change the
implementation of your getter function to something completely different
without breaking anything, but you won't be able to do that with your
reference solution.)