The following functions take the same parameter type:
void f1(const Widget *pw); // f1 takes a pointer to a constant Widget object void f2(Widget const *pw); // so does f2
Consider a class for representing a block of text:
class TextBlock { public: const char& operator[](std::size_t position) const // operator[] for const objects { return text[position]; } char& operator[](std::size_t position) // operator[] for non-const objects { return text[position]; } private: std::string text; }; TextBlock tb("Hello"); std::cout << tb[0]; // calls non-const TextBlock::operator[] const TextBlock ctb("World"); std::cout << ctb[0]; // calls const TextBlock::operator[] std::cout << tb[0]; // fine—reading a non-const TextBlock tb[0] = ’x’; // fine—writing a non-const TextBlock std::cout << ctb[0]; // fine—reading a const TextBlock ctb[0] = ’x’; // error!—writing a const TextBlock
There are two prevailing notions: bitwise constness (also known as physical constness) and logical constness.
The bitwise const camp believes that a member function is const if and only if it doesn't modify any of the object's data members (excluding those that are static), i.e., if it doesn't modify any of the bits inside the object.
Unfortunately, many member functions that don't act very const pass the bitwise test.
class CTextBlock { public: char& operator[](std::size_t position) const // inappropriate (but bitwise const) declaration of operator[] { return pText[position]; } private: char* pText; }; const CTextBlock cctb("Hello"); // declare constant object char* pc = &cctb[0]; // call the const operator[] to get a pointer to cctb's data *pc = 'J'; // cctb now has the value "Jello"
This leads to the notion of logical constness. Adherents to this philosophy — and you should be among them — argue that a const member function might modify some of the bits in the object on which it's invoked, but only in ways that clients cannot detect.
class CTextBlock { public: std::size_t length() const; private: char* pText; mutable std::size_t textLength; // these data members may mutable bool lengthIsValid; // always be modified, even in }; // const member functions std::size_t CTextBlock::length() const { if (!lengthIsValid) { textLength = std::strlen(pText); // now fine lengthIsValid = true; // also fine } return textLength; }
Having the non-const operator[] call the const version is a safe way to avoid code duplication, even though it requires a cast.
class TextBlock { public: //... const char& operator[](std::size_t position) const // same as before { //... //... //... return text[position]; } char& operator[](std::size_t position) // now just calls const op[] { return const_cast<char&>(static_cast<const TextBlock&>(*this)[position]); // cast away const on op[]’s return type add const to *this’s type call const version of op[] } //... };