http://wenku.baidu.com/view/7e042bec0975f46527d3e197.html
我们也许学习过const的使用，但是对于const的细致的技术细节却不一定掌握。const的用法在许多的教材上只是简单的介绍，在这里我们对const进行细致的概念以及用法剖析。const 是由c++采用，并加进标准c中，但是他们的意义完全不同，在旧版本(标准前)的c中，如果想建立一个常量，必须使用预处理器：
#define PI 3.14159
此后无论在何处使用PI，都会被预处理器以3.14159替代。编译器不对PI进行类型检查，也就是说可以不受限制的建立宏并用它来替代值，如果使用不慎，很可能由预处理引入错误，这些错误往往很难发现。
我们也不能得到PI的地址（即不能向PI传递指针和引用）。
c++引入了命名常量的概念，命名常量就像变量一样，只是它的值不能改变，如果试图改变一个const 对象，编译器将会产生错误。 const 和正常变量一样有作用域，所以函数内部的const也不会影响程序的其余部分。在c++中const可以取代预处理器#define来进行值替代，const有安全的类型检查，所以不用担心会像预处理器一样引入错误。
在通常的情况下const同预处理器#define一样只是将所赋值保存入编译器的符号表中（符号表仅仅在编译时存在，在编译过程中编译器将程序中的名字与之在符号表中定义的数值作简单的替换），在使用的时候进行值替换，并不为const创建存储空间。我们将const的定义放进头文件里，这样通过包含头文件，可以把const定义单独放在一个地方并把它分配给一个编译单元，const默认为内部连接（内部连接意味着只对正在编译的文件创建存储空间，别的文件可以使用相同的标示符和全局变量，编译器不会发现冲突，外部连接意味着为所有被编译过的文件创建一片单独的存储空间，一般全局变量和函数名的外部连接通过extern声明，可以通过其他的文件访问）也就是说const仅能被它所定义过的文件访问，在定义一个const时，必须赋一个值给它，除非用extern做出说明：
extern const int a;
这表示const的定义在其他的什么地方，这里仅仅是一个声明，但是这样的做法使const使用了外部连接，也就是说上面的extern强制进行了对const的存储空间分配，这样我们就无法再用const作为常量折叠（在可能的情况下，符号常量的值会代替改名字的出现，这个替代过程叫做常量折叠）使用了，即使我们在其他地方定义了const的值,如：
extern const int a=3;
因为const的值被放入了存储单元，在编译的过程中，编译器不会去读存储单元的内容。如果我们这样做：
int b[a];
编译器就会给我们一个错误信息。
想不为const分配存储空间是不可能的，因为对于复杂的结构，例如集合，编译器不会复杂到将集合保存到它的符号表中，所以必须分配内存空间，这就意味着“这是一块不能改变的存储空间”，当然也就不能在编译期间使用它的值，因为编译器不知道存储的内容：
const int i[]={1,2,3,4};
//float f[i[2]];
//将得到错误信息，编译器提示不能在数组定义里找到一个常数表达式。
因为编译器靠移动栈指针来存储和读取数据。
也因此，由于无法避免为const分配内存，所以const的定义必须默认为内部连接，否则由于众多的const在多个文件中分配内存，就会引起错误。下面我们看一段简单有效的代码来说明const的常量折叠：
#include <iostream.h>
const int a=3;
const int b=a+1;
float *f=(float*)&b;
char c[b+3];
void main()
{
const char gc=cin.get();
const char c2=gc+3;
}
我们可以看到，a是一个编译器期间的const，b是从a中计算出来的，由于a是一个const，b的计算值来自一个常数表达式，而它自身也是一个编译器间的const，接着下面指针f取得了b的地址，所以迫使编译器给b分配了存储空间，不过即使分配了存储空间，由于编译器已经知道了b的值,所以仍然不妨碍在决定数组c的大小时使用b。
在主函数main()里，标识符gc的值在编译期间是不知道的，这也意味着需要存储空间，但是初始化要在定义点进行，而且一旦初始化，其值就不能改变，我们发现c2是由gc计算出来的，它的作用域与其他类型const的作用域是一样的，这是对#define用法的一种改进。
在c++引进常量的时候，标准c也引入了const，但是在c中const的意思和在c++中有很大不同，在c中const的意思是“一个不能改变的普通变量”，const常量总是被分配存储空间而且它的名字是全局符即const使用外部连接。于是在c中：
const int size=100;
char c[size];
得出一个错误。但是在c中可以这样写：
const int size;
因为c中的const被默认为外部连接，所以这样做是合理的。
在c语言中使用限定符const不是很有用，如果希望在常数表达式里（必须在编译期间被求值）使用一个已命名的值，必须使用预处理器#define。
在c++中可以使指针成为const，这很有用，如果以后想在程序代码中改变const这种指针的使用，编译器将给出通知，这样大大提高了安全性。在用带有const的指针时，我们有两种选择：const修饰指针指向的对象，或者const修饰指针自己指向的存储空间。
如果要使指向的对象不发生改变，则需要这样写：
const int *p;
这里p是一个指向const int 的指针，它不需要初始化，因为p可以指向任何标识符，它自己并不是一个const，但是它所指的值是不能改变的，同样的，我们可以这样写：
int const *p;
这两种方法是等同的，依据个人习惯以及编码风格不同，程序员自己决定使用哪一种形式。
如果希望使指针成为一个const必须将const标明的部分放在*右边。
int a=3;
int *const j=&a
编译器要求给它一个初始值，这个值在指针的生命期间内不变，也就是说指针始终指向a的地址，不过要改变它地址中的值是可以的：
*j+=4;
也可以是一个const指针指向一个const对象：
const int *j1=&a;
int const *j2=&a;
这样指针和对象都不能改变，这两种形式同样是等同的。在赋值的的时候需要注意，我们可以将一个非const的对象地址赋给一个const指针，但是不能将一个const对象地址赋给一个非const指针，因为这样可能通过被赋值的指针改变对象的值，当然也可以用类型的强制转换来进行const对象的赋值，但是这样做打破了const提供的安全性。
const也被用于限定函数参数和函数的返回值，如果函数参数是按值传递时，即表示变量的初值不会被函数改变，如果函数的返回值为const那么对于内部类型来说按值返回的是否是一个cosnt是无关紧要的，编译器不让它成为一个左值，因为它是一个值而不是一个变量，所以使用const是多余的，例如：
const int f(){return 1;}
void main(){int a=f();}
但是当处理用户定义类型的时候，按值返回常量就很有意义了，这时候函数的返回值不能被直接赋值也不能被修改。仅仅是非const返回值能作为一个左值使用，但是这往往失去意义，因为函数返回值在使用时通常保存为一个临时量，临时量被作为左值使用并修改后，编译器将临时量清除。结果丢失了所有的修改。
可以用const限定传递或返回一个地址（即一个指针或一个引用）：
const int * const func(const int *p)
{ static int a=*p;
return &a;
}
参数内的const限定指针p指向的数据不能被改变，此后p的值被赋给静态变量a,然后将a的地址返回，这里a是一个静态变量，在函数运行结束后，它的生命期并没有结束，所以可以将它的地址返回。因为函数返回一个const int* 型，所以函数func的返回值不可以赋给一个非指向const的指针，但它同时接受一个const int * const和一个const int *指针，这是因为在函数返回时产生一个const临时指针用以存放a的地址，所以自动产生了这种原始变量不能被改变的约定，于是*右边的const只有当作左值使用时才有意义。
const同样运用于类中，但是它的意义又有所不同，我们可以创建const的数据成员，const的成员函数，甚至是const的对象，但是保持类的对象为const比较复杂，所以const对象只能调用const成员函数。
const的数据成员在类的每一个对象中分配存储，并且一旦初始化这个值在对象的生命期内是一个常量，因此在类中建立一个const数据成员时，初始化工作必须在构造函数初始化列表中。如果我们希望创建一个有编译期间的常量成员，这就需要在该常量成员的前面使用static限定符，这样所有的对象都仅有一个实例：
class X
{
static const int size=50;
int a[size];
public:
X();
};
const对象只能调用const成员函数，一个普通对象同样可以调用const成员函数，因此，const成员函数更具有一般性，但是成员函数不会默认为const。声明一个const成员函数，需要将const限定符放在函数名的后面：
void f (void ) const;
当我们运用const成员函数时，遇到需要改变数据成员，可以用mutable进行特别的指定：
class X
{
mutable int i;
public:
X();
void nochange() const;
};
void X::nochange const(){i++;}
const消除了预处理器的值替代的不良影响，并且提供了良好的类型检查形式和安全性，在可能的地方尽可能的使用const对我们的编程有很大的帮助。
注意：1、使用const修饰符定义常量时，必须初始化，但在类中不能在定义时初始化而是在构造函数中进行。
2、 与#define定义的常量有所不同，const定义的常量可以有自己的数据类型，这样C++编译程序可以进行更加严格的类型检查，编译时具有良好的检测性。且可以方便通过指针访问。
const关键字是用来修饰一个变量使其成为常量(constant)的。常量只能在定义时进行初始化，而此后对这个变量的任何改变都将是非法的。const关键字在就是为了保证了它修饰的对象不被修改。
对于指针来说，const关键字同样可以保证它修饰的对象不被修改，但是与一般的对象有所不同，const可以指定指针本身为常量，也可以指定指针所指的对象为常量，亦或兼而有之。咱们看看下面这个例子：
char* p = "Hello" //普通指针，#1
char* const p = "Hello" //常指针，const修饰指针p，#2
const char* p = "Hello" //指向常量的指针，const修饰指针所指向的内存, #3
const char* const p = "Hello" //指向常量的常指针，const同时修饰指针以及所指内存 #4
想理解上面的4个例子，最关键，是要理解const的作用对象是什么。
#1，无论修改p还是*p都没有问题；
可以修改*p，但不能修改已经被定义为常量的p，这相当于一个引用，用字符串Hello的地址初始化该常指针，创建一个常指针就是创建不能移动的固定指针，但是它所指的数据可以改变；
例如：p[2]='a';//合法
p="adadf";//非法
#3，const修饰指针p所指向的内存，所以指针可以修改，而这块内存不能修改；不允许改变指针所指向的常量，但可以改变p的值，例如p="adad";//是合法的
#4，这是一种极端情况，一般来说，在编程中很少用到，它就相当于一个const的引用。两者都不能改变。
const还在函数的声明中体现出强大的功能。它可以指定一个函数的返回值，或者函数的参数；而对于类的成员函数，const还可以修饰其访问权限。
我们来看一个简单的例子：
class my
{
public:
const int& get() const; // #5
int& get(); // #6
private:
int m_n;
};
int my::get() const
{
return m_n;
}
int& my::get()
{
return m_n;
}
我们看到在my这个类中，有两个几乎相同的函数，为什么这样的函数也可以重载呢？它们居然有用了相同的参数列表，不过此时的参数列表是空的。
不用害怕，有后缀const存在，可保无虞！
那么我们就来看看，这个const到底干了些什么勾当。
对于普通的成员函数来说，C++编译器在调用它们的时候，都会隐式的提供一个this指针，所以，其实我们刚刚看到的那两个函数的参数列表不是空的，只不过编译器在欺骗我们，当然，我们可不会上它的当。那么现在，我们如此理解它们：
const int& get(my* this) const; // #7
int& get(my* this); // #8
这依然使我们产生了一些视觉上的不快，虽然，它们不再使空参数列表，但是参数列表好像还是相同，显然，如果真是这样，真两个函数肯定是无法重载的，那么问题一定就在哪个const后缀上。
那么现在，我就可以回答大家的疑问：在成员函数的后缀加上const之后，将会导致这个函数的参数列表轻微的改变，被影响的参数就是那个鬼鬼祟祟的this指针，this指针将会被const重新修饰。从而那两个函数，我们就可以写成这样：
const int& get(const my* this); // #9
int& get(my* this); // #10
OK
小功告成，现在，立即重载！
好，那么，如何去区分这两个函数不同的调用呢？
其实，只要理解了以上的思想，这已经不存在障碍了，只要我们能够让一个对象成为const类型，那么它就会自动去选择被后缀const修饰过的重载函数。
我们在前面提到过const可以修饰函数的返回值？这是怎么回事呢？对一个返回值进行修饰？有意义吗？
当然，当然。其实，这不是一个语法上的问题，而是一个逻辑上的问题。我们还是使用那个万人迷例子吧：
class my_int
{
public:
my_int(int n)
{
m_n = n;
}
my_int& operator+(my_int a);
private:
int m_n;
}
my_int& operator+(my_int a)
{
m_n += a.m_n;
return *this;
}
现在，我们返回的是一个my_int对象的引用，如果，我们不限定它是一个const类型的话，将会允许下面的这种怪物出现：
my_int a(3), b(5), c(19);
(a += b) = c;
显然，这是不应该被允许的一种表达式，对一个结果进行赋值，是一种非常愚蠢和丑陋的行为，所以，我们要这样修改我们的operator+函数：
const my_int& operator+(my_int a);
文章出处：DIY部落(http://www.diybl.com/course/3_program/c++/cppjs/20091221/185243_3.html)