Re: Storing const references to other objects in another object.

From:

"Daniel T." <daniel_t@earthlink.net>

Newsgroups:

comp.lang.c++

Date:

Wed, 07 Apr 2010 19:04:09 -0400

Message-ID:

<daniel_t-9D2DA2.19040907042010@70-3-168-216.pools.spcsdns.net>

In article <wa-dnaUnes-ceiHWnZ2dnUVZ8oCdnZ2d@giganews.com>,
"Leigh Johnston" <leigh@i42.co.uk> wrote:

"Daniel T." <daniel_t@earthlink.net> wrote in message
news:daniel_t-DED790.14544907042010@70-3-168-216.pools.spcsdns.net...

"Leigh Johnston" <leigh@i42.co.uk> wrote:

"Daniel T." <daniel_t@earthlink.net> wrote:

James Allsopp <jamesaallsopp@googlemail.com> wrote:

I have a list of item objects which I'm trying to find which of
these objects are close to each other. The data in these objects
does not change. I const::iterate though the vector these are
stored in, and where the condition is met, create a linker object
in another class. I don't want to recreate the classes, just store
a reference to them. The code from the linker is

class linker{
public:
        linker( const item &spectra, const item & core, double
distance):spectra(spectra),core(core),distance(distance){};
        const item & spectra;
        const item & core;
        double distance;
        int toString() const;

};

References were designed for argument passing, and it isn't
appropriate to use them as member-variables. Hold your items in
const pointers instead.

Not true, references were designed to be an alias to another object
not just for argument passing.

Read "The Design and Evolution of C++" by Stroustrup. References were
introduced to facilitate argument passing in operator overloading. (full
stop)

It is perfectly fine to have reference member variables but if the
class needs to be Assignable (to be compatible with a container for
example) then reference member variables may not be suitable.

The fact that references can be used in other contexts does not change
the fact that they weren't originally designed to be used in those
contexts.

So what?

So it proves my assertion that references were designed for argument
passing.

The language evolves and so does the way its features are used.

But that doesn't change the original motivation for including a
particular feature.

The standard library containers use references for return types as well as
argument passing for example.

Which is exactly what they were designed for, as I already said. (A
return is passing an argument back to the caller.)

And according to Stroustrup (TC++PL):

<quote>
References can be used to simplify classes based on pointer membership when
only one object is referred to during the life of the containing object.
For example:

class C4 {
  X& r;
public:
  C4(X& q) : r(q) {}
  // ...
};
</quote>

I use the above idiom quite a lot in my code.

And it has already been pointed out how limited such an idiom is and its
limitations stem directly from the fact that references were designed
for argument passing.