c++ const member function question

Question

I am reading a book called 'Effective C++, Second Edition' and its talking about const member functions and how you have bitwise const-ness and conceptual const-ness.

It says most compilers will go with bitwise const-ness, which is that you cannot alter data members of an object inside a const member function.

Then there's an example of a member function that doesn't seem to act bitwise in the const test.

It goes like this:

#include "stdafx.h"
#include <string>
#include <iostream.h>

using namespace std;

class mystring
{

public:
    mystring(const char* value);

    operator char *() const { return data; }

private:
    char * data;
};

mystring::mystring(const char * value)
{

    mystring::data = const_cast<char*>(value);
}


int main(int argc, char* argv[])
{
    const mystring s = "Hello";

    char * nasty = s;

    *nasty = 'M';

    printf("s: %c", s);

    return 0;
}

When this is run, it says in my book it should allow you to change the value of s, even though its const. This because char* data is pointing to the same as const char* value is pointing. *data in this case is not const.

However trying to run this in MS VC++ 6.0, it throws an access violation at line *nasty = 'M';

Can someone explain what is going on? I think I've missed something?

To me it seems that because we have a const mystring s, we should not be able to change it, but then what it says in the books seems awkward.

Answer 1

The access violation is because you try to change a string literal. Your code is equivalent to:

char * p = "Hello";
* p = 'M';

which is illegal in both C and C++ - nothing to do with const member functions.

Answer 2

You get access violation only because the char* pointer is to a string literal. Changing a string literal is undefined behavior (AV in your case), it has nothing to do with const-correctness.

Answer 3

What you are doing is undefined behavior. You are casting away const-ness and trying to modify a constant value. If that example has been copied as-is from the book, then the book is wrong.

What is legal to do with const_cast<> is casting away constness from a constant pointer/reference to a non-const object:

int i = 5;
int const & ir = i;
const_cast<int&>(ir) = 7; // valid
int const * ip = &i;
*const_cast<int*>(ip) = 9; // valid

const int c = 11;
int const & cr = c;
const_cast<int&>(cr) = 13; // Undefined behavior

The reason that you cannot cast away const-ness from a reference to a real const object is that the compiler can decide to place the object in read-only memory, in which case the operation can fail in different ways (killing the application, ignoring the change...)

Answer 4

In your example, you don't change s, you try to change the memory where a member variable of s points to. Since you are allowed to place the const in many places, you have to be careful about what you actually declare const.

Your member function operator char*() const is not allowed to change any member variable. Try operator char *() const { data = "something else"; return data; } and your compiler will tell you that you are not allowed to modify data. However, in this case you simply return data without modification. That's allowed. You are even allowed to change the memory where data points to, as in operator char *() const { *data = 'M'; return data; }. However, this fails in your context since data points to a string literal which you are not allowed to change.