C++Talk.NET

mlimber · Guest

The code below compiles on various platforms, but I don't understand
why. Specifically, shouldn't B::Mutate() generate a compile-time error
since it is declared to be a const member function but actually changes
the member a_ [via the non-const A::Mutate()]? The trick seems to be in
the fact that B has a reference-to-A, although the compiler also
remains silent if B has a pointer-to-A or even a boost::shared_ptr<A>
instead.

class A
{
int i_;
public:
A( int i ) : i_( i ) {}
void Mutate() { i_++; }
};

class B
{
A &a_;
public:
B( A& a ) : a_( a ) {}
void Mutate() const { a_.Mutate(); } // !!!
};

Cheers!

M

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

R.F. Pels · Guest

mlimber wrote:

Gerhard Menzl · Guest

mlimber wrote:

mlimber · Guest

Nicola Musatti · Guest

The current solution allows you to distinguish between the pointer and
the pointed object. While the pointer is clearly a data member of your
class and thus should be subject to const correctness, the mere
presence of a pointer to it does not necessarily indicate that the
pointed object is owned by your class so I find it a good thing that it
is not subject to const correctness control: I'm glad to accept a
little risk of writing incorrect code in exchange for the higher degree
of freedom.

Cheers,
Nicola Musatti

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

mlimber · Guest

Isn't the same freedom available via "mutable" (or shouldn't it be)? By
contrast, under the current scheme, there seems to be no way to protect
referenced objects even if they are known to belong to the class and
should not be mutable under const member functions:

class C
{
A *const a_;
int i_;

public:
C( int i )
: a_( new A( i ) ), // Solely owned by C
i_( i )
{}

~C() { delete a_; }

void Mutate() const
{
i_++; // Error: Can't mutate here, as expected.
a_->Mutate(); // Ok, but possibly a mistake
}
};

I agree that const-correctness makes programs and classes "easier to
understand, track, and reason about" (_C++ Coding Standards_, p. 30),
but here is an instance where we cannot be const-correct in the way
that it is commonly explained (in fact, I find very little
documentation on this fine point in the standard references; Stroustrup
mentions it as an alternate technique to using "mutable" but doesn't
dwell on the apparent violation of const-ness).

This putative exception to the rule of const-ness not only makes things
harder to understand, track, and reason about (thus out-weighing the
benefits of the extra degree of freedom, IMHO), but also means that
trusting in const-correctness can lead to a false sense of security
since the behavior here is not what is advertised or intuitive for the
programmer (IMHO).

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

Dave Harris · Guest

[email]mlimber (AT) gmail (DOT) com[/email] (mlimber) wrote (abridged):

Allan W · Guest

mlimber wrote:

kanze@gabi-soft.fr · Guest

mlimber wrote:

mlimber · Guest

Dave Harris wrote:

Randy · Guest

Take a look at the post from Ahti Legonkov on 4/18/05 at 4:07 am in the
thread "Use of 'const' with pimpl objects" in this NG. He shows an
interesting wrapper around boost::scoped_ptr<> that makes the pointee
const if the pointer is. This may be just what you're looking for.

Randy.

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

Nicola Musatti · Guest

Again, this would impose on pointer and reference members the meaning
of owners of the pointed/referenced object, which is only one among
different possible interpretations. The correct way to achieve what you
want is to define a smart pointer class that has the behaviour you
want, something like:

template <typename T> class owning_ptr {
public:
// ...
const T * operator * () const { return ptr; }
T * operator * () { return ptr; }
private:
T * ptr;
};

Cheers,
Nicola Musatti

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

mlimber · Guest

Dave Harris · Guest

[email]mlimber (AT) gmail (DOT) com[/email] (mlimber) wrote (abridged):

mlimber · Guest