1.1.7.1 const and mutable

• Just like assert, Use const aggressively
• Top-level const to indicate that the pointer itself is a const. When a pointer can point to a const object, we refer to that const as a low level const.
• For reference, you always can’t change it, so only low-level const.
  int i = 0; 
  int * const p1 = &i; // const is top-level 
  const int *p2 = &ci; // const is low-level 
   
  const int *const p3 = p2; 
  // right most const is top-level, left-most is not 
  const int &r = ci; 
  // const in reference type is always low-level
• const mainly used in :
  1. functions parameter.
  2. function return value. ( just used for const reference)
  3. member function.
• The const qualifier prevents code inside the function from modifying the parameter itself. Such an assurance helps you to quickly read and understand a function. Under some circumstances, this might even help the compiler generate better code.
  double cube (const double side){ 
      return side * side * side; 
  }
• In fact, to the compiler, the function signature is the same whether you include this const in front of a value parameter or not. For example:
  int f( int ); 
  int f( const int ); // redeclares f(int) 
  // no overloading, there’s only one function
• In C++, When you use pointer or reference as function parameter, You should always put const in front of it. Becuause 90% you don’t need to modify it. Once you compiler bark, then you can delete const, It’s funny.
• When function return build-in value, don’t use const at all.
  const int foo() { 
     return 3; 
  } 
  int x = foo();  // copies happily 
  foo() = 4;  // not valid anyway for built-in types
• When function return user-defined type value, don’t use const at all. It will not allow you to use rvalue and move.
  const time operator+(const time &t){ 
     time temp; 
     return temp.bla = bla+t.bla; 
  } 
   
  //because + return const, so below just copy 
  //not use time move ctor, low efficient. 
  time t3(t1+t2);
• When function return reference or pointer, you can use const to restrict modify it.
  class String{ 
  const char& operator[](int position); 
  }
• When const used in member function. There are four points.
  1. In const member function, you can’t change member variable,(If you change it, it will compile error).
     time operator+(const time & t1) const{ 
        this->m_a = 100// will compile error 
     }
  2. Only const obj can call const function. But non-const obj can call ALL funcitons( const or non-const).
     class Fred { 
     public: 
       void inspect() const; 
       // This member promises NOT to change *this 
       void mutate(); 
       // This member function might change *this 
     }; 
      
     void userCode(Fred& changeable, const Fred& unchangeable){ 
       changeable.inspect();   // Okay: doesn’t change 
       changeable.mutate();    // Okay: changes 
       unchangeable.inspect(); // Okay: doesn’t change 
       unchangeable.mutate();  //______________________// ERROR: 
     }
  3. If you want to return a member of a object from a const method, you should return it using reference-to-const (const X& inspect() const) or by value ( X inspect() const). const member method return value or const reference.
     class Person { 
     public: 
       const std::string& name_good() const; 
       // Right: the caller can’t change the Person’s name 
      
       std::string& name_evil() const; 
       // Wrong: the caller can change the Person’s name 
      
       int age() const; 
       // Also right: the caller can’t change the Person’s age 
       // ... 
     }; 
      
     void myCode(const Person& p){ 
      // const p means not to change the Person object 
       p.name_evil() = "Igor";  // But changed....!! 
     }
  4. The most common use of const overloading is with the subscript operator. You should generally try to use one of the standard container templates, such as std::vector, but if you need to create your own class that has a subscript operator, here’s the rule of thumb: subscript operators often come in pairs.
     class Fred { /*...*/ }; 
     class MyFredList { 
     public: 
       _____________________const Fred& operator[] (unsigned index) const; 
       // Subscript operators often come in pairs 
      
       Fred&  operator[] (unsigned index); 
       // Subscript operators often come in pairs 
     };
• Do not use "volatile" except in low-level code that deals directly with hardware.
  void waitForSemaphore(){ 
     volatile uint16_t* semPtr = WELL_KNOWN_SEM_ADDR; 
     /*well known address to my semaphore*/ 
     while ((*semPtr) != IS_OK_FOR_ME_TO_PROCEED); 
  }
• "mutable" allows you to modify a member variable in a class by a const method.
• Behind "mutable", It’s bitwise const and logical const. Logical const is when an object doesn’t change in a way that is visible through the public interface. An example would be a class that computes a value the first time if required, then caches the result.
  class Foo  { 
  private: 
      mutable bool done_; 
  public: 
      void doSomething() const { ...; done_ = true; } 
  };