Can C++ compiler assume a const bool & value will not change?

Can the C++ compiler assume a 'const bool &' value will not change?

For example, imagine that I have a class:

class test {
public:
  test(const bool &state)
    : _test(state) {
  }

  void doSomething() {
    if (_test) {
      doMore();
    }
  }
  void doMore();

private:
  const bool &_test;
};

And I use it as follows:

void example() {
  bool myState = true;
  test myTest(myState);

  while (someTest()) {
    myTest.doSomething();
    myState = anotherTest();
  }
}

Is it allowed by the standard for the compiler to assume _test's value will not change.

I think not, but just want to be cer开发者_开发技巧tain.

No. Just because your reference (or pointer) is a const does not stop someone else from having a non-const reference. Like this:

int main(void) {
  bool myState = true;
  test myTest(myState);
  std::cout << myTest.getState() << std::endl;
  myState = false;
  std::cout << myTest.getState() << std::endl;
}

Or even more simply:

bool a = true;
const bool& b = a;
a = false; // OK
b = true; // error: assignment of read-only reference ‘b’

const Type & r means that "the value of r cannot be changed through this reference to it" - but it may well be changed by other code that has direct access to the referenced value (or through a non-const reference or pointer). The same goes for a const Type * p: "the value that p points to cannot be changed through this pointer to it.

You're right, it can't assume that, because the value of the referand of _test might be modified in the implementation of doMore, which is unavailable at compile-time. Since in this case myState is not a const object, it's valid (for example) for doMore to cast away const and modify it. Note valid, not advisable ;-)

And in general, doMore might call functions that have other pointers/references to the same bool object by another route. In your example there are no other references taken, so if the compiler can see all the code that might possibly reference it (including the definition of doMore), and none of it modifies the value, then it can make the assumption.