return vals[vals_ind];

}

// Const correct version. Is identical to above version, so most of it shall be skipped. template<typename T>

const T& good_func(const std::vector<T>& v, Helper<T>& h) {

//...

//We're feeling tired all of a sudden, and this happens. if (vals_ind != -1) {

vals[vals_ind] = temp; } else {

v.push_back(temp); // Error: discards qualifiers. vals_ind = vals.size() - 1; h.register_index(v_ind, vals_ind);

}

return vals[vals_ind];

}

Section 128.4: Const Correctness as Documentation

One of the more useful things about const correctness is that it serves as a way of documenting code, providing certain guarantees to the programmer and other users. These guarantees are enforced by the compiler due to constness, with a lack of constness in turn indicating that code doesn't provide them.

const CV-Qualified Member Functions:

Any member function which is const can be assumed to have intent to read the instance, and:

Shall not modify the logical state of the instance they are called on. Therefore, they shall not modify any member variables of the instance they are called on, except mutable variables.

Shall not call any other functions that would modify any member variables of the instance, except mutable variables.

Conversely, any member function which isn't const can be assumed to have intent to modify the instance, and:

May or may not modify logical state.

May or may not call other functions which modify logical state.

This can be used to make assumptions about the state of the object after any given member function is called, even without seeing the definition of that function:

// ConstMemberFunctions.h

class ConstMemberFunctions { int val;

mutable int cache;

mutable bool state_changed;

public:

//Constructor clearly changes logical state. No assumptions necessary. ConstMemberFunctions(int v = 0);

//We can assume this function doesn't change logical state, and doesn't call

//set_val(). It may or may not call squared_calc() or bad_func().

int calc() const;

//We can assume this function doesn't change logical state, and doesn't call

//set_val(). It may or may not call calc() or bad_func().

This can be used to make assumptions about the state of the parameters after being passed to any given function, even without seeing the definition of that function.

//function_parameter.h

//We can assume that c isn't modified (and c.set_val() isn't called), and isn't passed

//to non_qualified_function_parameter(). If passed to one_const_one_not(), it is the first

//parameter.

void const_function_parameter(const ConstMemberFunctions& c);

//We can assume that c is modified and/or c.set_val() is called, and may or may not be passed

//to any of these functions. If passed to one_const_one_not, it may be either parameter. void non_qualified_function_parameter(ConstMemberFunctions& c);

//We can assume that:

//l is not modified, and l.set_val() won't be called.

//l may or may not be passed to const_function_parameter().

//r is modified, and/or r.set_val() may be called.

//r may or may not be passed to either of the preceding functions.

void one_const_one_not(const ConstMemberFunctions& l, ConstMemberFunctions& r);

//We can assume that c isn't modified (and c.set_val() isn't called), and isn't passed

//to non_qualified_function_parameter(). If passed to one_const_one_not(), it is the first

//parameter.

void bad_parameter(const ConstMemberFunctions& c);

Due to const rules, these assumptions will in fact be enforced by the compiler.

//function_parameter.cpp

//Our assumption was correct.

void const_function_parameter(const ConstMemberFunctions& c) {

std::cout << "With the current value, the output is: " << c.calc() << '\n'

<<"If squared, it's: " << c.squared_calc()

<<std::endl;

}

// Our assumption was correct.

void non_qualified_function_parameter(ConstMemberFunctions& c) { c.set_val(42);

std::cout << "For the value 42, the output is: " << c.calc() << '\n'

<<"If squared, it's: " << c.squared_calc()

<<std::endl;

}

//Our assumption was correct, in the ugliest possible way.

//Note that const correctness doesn't prevent encapsulation from intentionally being broken,

//it merely prevents code from having write access when it doesn't need it.

void one_const_one_not(const ConstMemberFunctions& l, ConstMemberFunctions& r) { // Let's just punch access modifiers and common sense in the face here. struct Machiavelli {

int val;

int unimportant; bool state_changed;

};

reinterpret_cast<Machiavelli&>(r).val = l.calc(); reinterpret_cast<Machiavelli&>(r).state_changed = true;

const_function_parameter(l); const_function_parameter(r);

}

//Our assumption was incorrect.

//Function fails to compile, due to `this` losing qualifiers in c.set_val(). void bad_parameter(const ConstMemberFunctions& c) {

c.set_val(18);

}

While it is possible to circumvent const correctness, and by extension break these guarantees, this must be done intentionally by the programmer (just like breaking encapsulation with Machiavelli, above), and is likely to cause undefined behaviour.

class DealBreaker : public ConstMemberFunctions { public:

DealBreaker(int v = 0);

// A foreboding name, but it's const...

void no_guarantees() const;

}

DealBreaker::DealBreaker(int v /* = 0 */) : ConstMemberFunctions(v) {}

//Our assumption was incorrect.

//const_cast removes const-ness, making the compiler think we know what we're doing. void DealBreaker::no_guarantees() const {

const_cast<DealBreaker*>(this)->set_val(823);

}

//...

const DealBreaker d(50);

d.no_guarantees(); // Undefined behaviour: d really IS const, it may or may not be modified.

However, due to this requiring the programmer to very specifically tell the compiler that they intend to ignore constness, and being inconsistent across compilers, it is generally safe to assume that const correct code will refrain from doing so unless otherwise specified.