Simple question about C++ constant syntax

Question

Here is some code copied from Thinking in C++ Vol1 Chapter 10.

   #include <iostream>
   using namespace std;

   int x = 100;

   class WithStatic {
        static int x;
        static int y;
        public:
             void print() const {
             cout << "WithStatic::x = " << x << endl;
             cout << "WithStatic::y = " << y << endl;
           }
  };

what's the meaning of const for the function print()? Thanks!

Answer 1

It's a guarantee that the function won't modify the object at all (i.e. it's a "read-only" function). EDIT: Apparently, the exception to that rule is if an object has mutable members; those can be changed by both const and non-const functions.

Also, I'm glad to see somebody else learning from TIC++. It's a great resource for beginners.

Answer 2

the const means print() is not allowed to modify state variables not marked with volatile.

Answer 3

It means that it doesn't change any member variables of the class.

http://www.parashift.com/c++-faq-lite/const-correctness.html

Answer 4

What it does is effectively make the this pointer be a const pointer to const instead of a const pointer to non-const. So, any time that you reference this in a const member function - either explicitly or implicitly - you're using a const pointer to const.

So, in the case of the class you have here, in any non-const function, the type of this is WithStatic const * while in the const functions, its type is const WithStatic * const.

Like with any pointer to const, you can't alter anything that it points to. So, you can't alter any of its member variables, and you can't call any of its non-const member functions.

Generally speaking, it's a good idea to make a member function be const if you can reasonably do so, because it guarantees that you're not going to alter the object's state, and you can call it with a const object.

It is possible for member variables to be altered if they're mutable or volatile, but those are more advanced topics that are probably better avoided until you're more familiar with the language. Certainly, you don't usually need to worry about them and shouldn't use them unless you need to. It's also possible to cast away the constness of the this pointer, at which point you could alter it, but IIRC, that's undefined behavior, and it's definitely generally considered a bad idea. So, there are instances where it's possible to alter an object's state within a const member function, but it's not normally possible and best avoided even when it is.

When you make a member function const, you're effectively promising that the object's state will not be changed by that function call (though there can obviously be side effects as evidenced by the fact that you can call functions like printf()).

Answer 5

If a member function is declared "const", it means that the function will not modify the object's state. This:

• Documents the fact that the function will not modify state (useful to other developers).
• Allows the compiler to make optimizations, knowing that the result of other "const" functions will not have changed as a result of calling that function (which allows function calls to be taken out of loops).
• Enables one to call the function when the object is passed by const reference, const pointer, etc.

For all the above reasons, one should, as a general rule of thumb, declare a function as "const" if it does not logically modify the state of the object. If the logical state of the object changes, then don't use "const". As an aside, there are cases where the actual state changes but the logical state does not (e.g. caching), in which case one should still mark the function as "const", but one needs to use the "mutable" keyword with the caching variables in order to tell the compiler that modifying them actually doesn't change the logical state.