const 总结

1.const修饰的变量不能被修改，即只是可读

const int 与 int const相同

2.修饰指针时：

int b=100;
const  int * a=&b  [1];
int   const   *a=&b;     [2] 
int*   const   a=&b;     [3] 
const   int*   const   a =&b;     [4]
如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；
如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量（const放在变量声明符的位置无关），这种情况下不允许对内容进行更改操作，如不能*a   =   3   ；
[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；
[4]为指针本身和指向的内容均为常量。

必须初始化

   const int i=5;    //合法

   const int j;      //非法，导致编译错误

class CExample()
{
public:
     const int* getData() const       //后面的const是为了保护成员变量在方法
                                      //内不会被修改（修饰成员变量）
                                      //前面的const是为了保证在外部调用该方法后，
                                      //返回值不会被篡改（修饰方法）
    {
           return &m_data;
    }
private:
     int m_data;   
}        

const 引用形参

const引用传递

    find（const int  &x）{}

    y= find(z)；

    上面的例子中，z是实参，x是形参。z不随x而改变。

    有人就会问了，你这样做不是和值传递一样的么？NO！

    仔细观察就会发现，在值传递中要进行两次拷贝，浪费内存资源是相当可耻的，const的出现有效避免了这种情况的出现，只需拷贝一次就够了。

const的常量值可以被修改

   const int i=0;

   int *p=(int*)&i;

   *p=100;

   通过强制类型转换，将地址赋给变量，再作修改即可以改变const常量

修饰类成员变量

用const修饰的类成员变量，只能在类的构造函数初始化列表中赋值，不能在类构造函数体内赋值。

class A
{
public：
    A(int x) : a(x)  // 正确
    {
         //a = x;    // 错误
    }

private：
    const int a;
};

修饰类成员函数

用const修饰的类成员函数，在该函数体内不能改变该类对象的任何成员变量, 也不能调用类中任何非const成员函数。

class A
{
public:
    int& getValue() const
    {
        // a = 10;    // 错误
        return a;
    }

private:
    int a;            // 非const成员变量
};

修饰类对象

用const修饰的类对象，该对象内的任何成员变量都不能被修改。
因此不能调用该对象的任何非const成员函数，因为对非const成员函数的调用会有修改成员变量的企图。

class A
{
 public:
    void funcA() {}
    void funcB() const {}
};

int main
{
    const A a;
    a.funcB();    // 可以
    a.funcA();    // 错误

    const A* b = new A();
    b->funcB();    // 可以
    b->funcA();    // 错误
}