Re: Logical constness

From:

Ulrich Eckhardt <eckhardt@satorlaser.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Fri, 8 Jan 2010 07:45:05 CST

Message-ID:

<em8j17-ho3.ln1@satorlaser.homedns.org>

Anubhav wrote:

struct A{
    A(){mp = mbuf; mbuf[2] = 'A';}
    char mbuf[10];
    char mc;
    char *mp;
};

int main(){
    A const obj; // a const object
    (obj.mbuf)[2] = 'B'; // L1
    (obj.mp)[2] = 'B'; // L2
}

I am unable to understand why L1 is an error but L2 is not. What
difference does it make in this case to access the memory location in
the array buf, using 'buf' in Line 1 and using 'mp' in Line 2? In both
of these lines.

Actually, both are errors. It's just that one is a compile-time error while
the other simply invokes undefined behaviour.

Example:

    int const n = 42;
    int& nn = const_cast<int&>(n);
    ++nn;

This code is similar to L2, it retrieves a non-const reference to a constant
and modifies it. Since in your example the struct A contains a
back-reference to itself (mp), this class can modify itself even though it
is constant, because the constant is not even known or knowable at the time
the different parts are compiled.

Note: I'm assuming you did not mean that you expect the 'mp' member to
suddenly become a pointer-to-const when the containing object is const.
That's a related but still different issue.

Uli

--
Sator Laser GmbH
Gesch??ftsf??hrer: Thorsten F??cking, Amtsgericht Hamburg HR B62 932

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