Re: const-correctness loopholes

From:

Paavo Helde <myfirstname@osa.pri.ee>

Newsgroups:

comp.lang.c++

Date:

Fri, 15 Apr 2011 15:13:53 -0500

Message-ID:

<Xns9EC8EC528C4BBmyfirstnameosapriee@216.196.109.131>

noir <none@none.no> wrote in news:4da89d59$0$38645
$4fafbaef@reader1.news.tin.it:

Hello,
I was reading about const-correctness on wikipedia:
http://en.wikipedia.org/wiki/Const-correctness

and things mostly made sense until I got to the part where "shallow"
const-correctness is discussed, and a solution is presented (i.e.
wrapping the struct/class with a const-correct interface):

--- quote ---
The latter loophole can be closed by using a class to hide the pointer
behind a const-correct interface, but such classes either don't support
the usual copy semantics from a const object (implying that the
containing class cannot be copied by the usual semantics either) or
allow other loopholes by permitting the stripping of const-ness through
inadvertent or intentional copying.
--- quote ---

So it looks like there's a dark side to this solution, but... what is
it?! I cannot make it out from the above snippet.

I am not quite sure either what they mean. Let's try to construct a class
with const-correct interface and then copy it:

class B;

class A {
public:
const B* GetB() const {return b_;}
B* GetB() {return b_;}
private:
     B* b_;
}

void f(const A& a1) {
     A a2 = a1;
     B* mutable_b = a2.GetB();
     // here, a2.GetB() returns a non-const pointer
     // to the original B object.
       // I guess this can be considered a loophole.
};

In my mind, this is not so large loophole because if A really owns the B
object, it should be deep-copied in A's copy ctor and the new copy can be
considered non-const, or otherwise if it is not owned by A then A's
constness should not dictate B's constness anyway.

Cheers
Paavo