Re: Modifying mutable data via const references.

From:

Andrey Tarasevich <andreytarasevich@hotmail.com>

Newsgroups:

comp.lang.c++

Date:

Thu, 21 Feb 2008 20:29:05 -0800

Message-ID:

<uvCdnYNIuIfw0iPanZ2dnUVZ_remnZ2d@comcast.com>

jason.cipriani@gmail.com wrote:

Hello,

Recently, in this newsgroup, I learned that if you bind an object to a
const reference, like this:

SomeObject a;
const SomeObject &ca = a;

And also like this:

void function (const SomeObject &ca);
SomeObject a;
function(a);

The compiler is completely free to create a copy of the object and
pass a reference to that copy instead, if it wants. I may be wrong
about this.

You are wrong. Apparently, you misunderstood something. In this specific case
the language specification strictly requires that the reference is bound
directly to the initializer lvalue object. No copies can be created.

What about something like this (same definition of SomeObject as
above) (in general, I know I am leaving a lot out of this snippet):

std::set<SomeObject>::const_iterator ci = SomeObjects.find(SomeKey);
(*ci).n = 3;

Is it possible that that code would not change the 'n' member of the
object in the set?

I'm not sure that the behavior is defined in this case, but it really has
nothing to do with the above issue if reference binding. It's more about
standard container specification.

I also learned recently that the compiler is free to create a copy of
an object when casting away it's const, such as when using
const_cast<> or a C-style cast. Does that mean that the following is
undefined (a contrived example, I know):

struct SomeObject {
  int n;
  void SetNTo3 (void) { n = 3; }
};

void function (const SomeObject &c) {
  (const_cast<SomeObject &>(c)).SetNTo3();
}

Is it possible that the const_cast will have caused a copy of 'c' to
be created, and so SetNTo3() applies to a different, temporary
instance?
...

No, it is not. The result will always refer to the same object.

--
Best regards,
Andrey Tarasevich