const成员函数、const类对象、mutable数据成员

1. const成员函数 只是告诉编译器，表明不修改类对象. 但是并不能阻止程序员可能做到的所有修改动作，比如对指针的修改，编译器可能无法检测到
2. 类体外定义的const成员函数，在定义和声明处都需要const修饰符

 1 class classname
 2 {
 3 public:
 4     classname() {}
 5     ~classname();
 6 
 7     void foo() const;
 8     char &operator[](int i);
 9 private:
10     //.
11 }
12 
13 void classname::foo() const
14 {
15 //
16 }
17 
18 char &classname::operator[](int i)
19 {
20 //..
21 }
22 int main()
23 {
24     const classname obj();
25     obj.foo();//ok
26     obj[2];//error,coz [] not const
27 }
28 

3. const对象为常量对象，它只能调用声明为const的成员函数。但是构造函数和析构函数是唯一不是const成员函数却可以被const对象调用的成员函数。 当然，一般对象当然也可以调用const成员了

 1 class A
 2 {
 3 public:
 4     A(int x, int y) : _x(x), _y(y) {}
 5     //int get() { return _x;}
 6     int get() const { return _y;}
 7 private:
 8     int _x, _y;
 9 };
10 
11 int main()
12 {
13     A obj(2, 3);
14     const A obj1(2, 3);
15     cout << obj.get() << " " << obj1.get();//3 3
16     
17     return 0;
18 }
19 

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class A
 5 {
 6 public:
 7     A(int x, int y) : _x(x), _y(y) {}
 8     int get() { return _x;}
 9     //int get() const { return _y;}
10 private:
11     int _x, _y;
12 };
13 
14 int main()
15 {
16     A obj(2, 3);
17     const A obj1(2, 3);
18     cout << obj.get() << " " << obj1.get();
19     //错误，obj1为常量对象，不能调用非const方法
20     return 0;
21 }

4. const成员函数可以被相同参数表的非const成员函数重载

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class A
 5 {
 6 public:
 7     A(int x, int y) : _x(x), _y(y) {}
 8     int get() { return _x;}
 9     int get() const { return _y;}
10 private:
11     int _x, _y;
12 };
13 
14 int main()
15 {
16     A obj(2, 3);
17     const A obj1(2, 3);
18     cout << obj.get() << " " << obj1.get();
19     // 2  3
20     return 0;
21 }
22 

4. 为了允许修改一个类的成员变量，即使是一个const对象的数据成员，于是引入了mutable
通过将数据成员声明为mutable， 表明此成员总是可以被更新，即使在一个const成员函数中。