Re: classes and const reference

1337-chixor;) schrieb:


You can consider a reference, indicated by &, as an "alias" to an
existing object. To explain that, let's say there exists a named
object
x of type ListOfElements:

ListOfElements x; // No reference, it's a named object

Now you can create a reference ("alias") to that object as follows:

ListOfElements& refX = x;

Note that this assignment does *not* call the copy-constructor
of ListOfElements, it will simply create an alternative name "refX"
of the existing object x. The standard does not require that such
a reference actually needs any memory (in the above scenario), it
could be done by just introducing another symbolic name for the
same entity x. You can test this identity by checking that the
adress of refX and x point to the same location:

assert(&x == &refX);

There exists several occasions, where such an elimination of
a reference entity is not possible. If so, the compiler can choose
the cheapest solution, to fulfill the basic requirement, that is to
fulfill the adress equality. Usually this will be done by using a
pointer to represent a reference.

One case, where a reference symbol alone is not sufficient, is
when a function takes a reference as argument. This is so,
because we can think of a function call as a kind of barrier, which
can only be climbed by globally available names and by it's
parameters. And a parameter must be something real, to allow
transport of (adress) information. Again, the compiler will usually
choose something similar to a pointer, but will always create code,
as if the pointer can be referenced - there is nothing like a NULL-
reference! *Warning*: If you have already Java or Delphi background,
this might wonder you. Actually Java/Delphi/C# references have
more similarities to C++ pointers than to C++ references.

Returning to your question lets have a look again at your
function declaration:

ListOfElements reverse(const ListOfElements&);

We can make several observations here: The is only one argument
of type reference to const ListOfElements (without a name). You
should already know the const: It requires's that programmer's can
only use const-qualified member functions and any member data
members of the given entity. So if you have to write the
implementation
of such a function, you will probably first assign a name to the
argument, such that you can do something with it. Here a starting
point:

ListOfElements reverse(const ListOfElements& list) {
    ...
    return ....;
}

Given your definition of ListOfElements and your knowledge how
to define an instance of ListOfElements and to reverse such a list,
you should now be able to solve your problem.

If you have further questions, please ask, but be aware that these
questions are not actually the problem you are supposed to solve
on your own ;-)

Greetings from Bremen,

Daniel Kr?gler

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]