const用法
1，定义全局变量的内存分配问题
#define Pi_1 3.14 //使用#define宏
const double Pi_2 = 3.14 //使用const,这时候Pi并没有放入内存中
double a = Pi_2; //这时候才为Pi分配内存,不过后面再有这样的定义也不会再分配内存
double b = Pi_1; //编译时分配内存
double c = Pi_2; //不会再分配内存,
double d = Pi_1; //编译时再分配内存
const定义的变量，系统只为它分配一次内存,而使用#define定义的常量宏，能分配好多次,这样const就很节约空间
2，const修饰变量
1、限定符声明变量只能被读
const int i=5；
int j=0；
……
i=j； //非法，导致编译错误
j=i； //合法
2、 必须初始化
const int i=5； //合法
const int j； //非法，导致编译错误
3、在另一连接文件中引用const常量
extern const int i； //合法
extern const int j=10； //非法，常量不可以被再次赋值
3，指向常量的指针变量
int a = 10;
int b = 20;
const int* p = &a; // assignment of read-only location ‘* p’, 即*p为只读的，不能对*p进行写操作。
int const* p1 = &a; //同上
*p = 11; // error
p = &b; // ok, 此时 *p = 20;
4，常量指针
int * const p2 = &a; //assignment of read-only variable ‘p2’, 即p2始终指向&a，不可被改变，但是可对*p2 做读写操作。
p2 = &b; // error
*p2 = b; // ok , 此时 *p2 = 20，由于p2始终指向&a，所以此时 a = 20；
5，指向常量的常量指针
const int * const p3 = &a; //此时p3始终指向 &a，并且不能对*p3做“写”操作。但是可以通过 a = 12 去改变*p3的值。
6，const限定类的成员函数
这种用法只在C++中有用(C语言中没有成员函数).如:
class classname
{
public:
int func() const
{... ...;}
}
采用这种const后置的形式一种规定，为了不引起混淆，在此函数的声明中和定义中均要使用const，因为const已经成为类型信息的一部分.但要注意，这种情况下，该函数不能修改类的非静态（static）数据成员，也不能在函数中调用其它非const的函数.比如:
class base
{
int x;
static int y;
public:
void foo() { cout << “foo” << endl;}
void foo() const { cout << “foo const” << endl;}
void foo1() { cout << “foo1” << endl;}
void foo2() const { cout << “foo2 const” << endl;}
static void foo3() { cout << “foo3” << endl;}
void test() const
{
int c;
x = 5; //错误
y = 10; //正确
foo() //正确
foo1(); //错误
foo2(); //正确
foo3() //正确
c = 10; //正确
}
}
这种情况下，在函数内部无法改变成员数据x的值，因此编译器会报错:"l-value secifies const object".
尽管函数名和参数列表都相同，void foo( ) const成员函数是可以与void foo( )并存的，可以形成重载! 我们假设调用语句为obj.foo()，如果obj为non-const对象，则调用foo()。如果obj为const对象，则调用foo()const。另外要注意，假如没有提供foo()const，则const obj调用foo()将会报错。但假如是没有提供foo()，则non-const obj调用foo()const是完全没有问题的。也就是说，non-const对象可以调用const函数(当然也可以调用non-const函数)，但const对象不能调用non-const函数。
const关键字所起作用的本质，就是把隐藏着的默认的this指针参数，改成const类型。也就是说：假如void foo( )函数被编译器改写为 void foo(T* pThis)，则void foo( ) const将会被改写为void foo(const T* pThis) 。i.e. 在函数末尾添加一个const，就相当于在隐藏的this参数类型前加一个const.
这样做有两个效果，第一：编译器将不允许foo()const修改pThis指向的对象的成员。第二、const对象只能调用const成员函数，否则就会报错说把const T* 转化为T* 会丢失qualifier