1）先看const常量的情况：

const int a=2;
int const b=c; // c是已经声明过的整型
两者都可以。本地的const常量必须在第一次声明时就初始化，用变量或常量

初始化都可以，只是初始化一次以后它的值就不能再改变了，此所谓const的

含义。
#include<iostream>
using namespace std;
int main()
{
int b;
//int a,b,c; error:redefinition; different type

// modifiers
b=7;
const int a=2;
// a+=b; error:1-value specifies const object
cout<<a<<endl;
int const c=b;
// c+=b; error:1-value specifies const object
cout<<c<<endl;
return 0;
}
................................................................

2）接着看指向常量的指针：

const int *pa;
int const *pa;
两者也等价。因为指向常量的指针有时候会指向常量，所以它具有这个性质

：“不能靠解引用改变它指向的对象的值”，以此保护它所指向的常量的常

量性：
*pa =d; // 不可行（d是已经声明过的整型）

但指针本身的值是可变的：
pa=& d; // 可行（d是已经声明过的整型）

而且指向常量的指针有时候也会指向变量，如下：
int t,u;
const int *pa;
pa =&t; //可行，指向变量t
pa =&u; //也可行，指向变量u

我们可以把它理解成：“为了指向常量而发明的指针”，这样比较贴切。

#include<iostream>
using namespace std;
int main()
{
int a=3;
int b=4;

const int *pa;
int const *pb;
pa=&a;
pb=&b;
// *pa =a; //l-value specifies const object
//*pa =&a; //cannot convert from 'int *' to 'const int'
cout<<a<<endl<<pa<<endl<<*pa<<endl;
cout << typeid( a ).name() << endl;
cout << typeid( pa ).name() << endl;
cout << typeid( pb ).name() << endl;
cout << typeid( *pb ).name() << endl;
/* int const c=b;
//c+=b;
cout<<c<<endl;
cout << typeid( c ).name() << endl; */

return 0;
}

................................................................
3)然后看常量指针的情况：

int *const pa =&n; // n是之前已经声明过的整型变量，注意必须是变量，

理由见下

“常量指针”即指针本身的值是常量，但“能靠解引用改变它指向的对象的

值”，如下：
pa=&d; // 不可行（d是已经声明过的整型）
*pa =d; // 可行（d是已经声明过的整型）

因为常量指针也是一种const常量，所以它同样必须在第一次声明时就初始化

，不过它的初始值缩小为只能是变量（的地址），因为只有变量才能确保以

后能靠解引用而改变它指向的对象的值。这使得常量指针不象一般的const常

量，用变量或常量初始化都可以。
也就是说，常量指针反而总是指向变量的。

#include<iostream>
using namespace std;
int main()
{ int n;
// int a=3;
// int b=4;

// const int *pa;
int *const pa =&n;
// int const *pb;
// pa=&a;
// pb=&b;
// *pa =a; //l-value specifies const object
//*pa =&a; //cannot convert from 'int *' to 'const int'
*pa =n;
// pa=&n; error : l-value specifies const object

cout << typeid(*pa).name() << endl;
cout << typeid( &n ).name() << endl;
// cout<<a<<endl<<pa<<endl<<*pa<<endl;
// cout << typeid( a ).name() << endl;
cout << typeid( pa ).name() << endl;
// cout << typeid( pb ).name() << endl;
// cout << typeid( *pb ).name() << endl;
/* int const c=b;
//c+=b;
cout<<c<<endl;
cout << typeid( c ).name() << endl; */

return 0;
}
................................................................
4）最后，是前面两者的结合：指向常量的常量指针
const int *const c=&e; //e是已经声明过的整型，整型常量或整型变量都

可以

把它理解成一个普通的const常量，同时被剥夺了“靠解引用改变它指向的对

象的值”的性质的就行。
看下面的三个例子...
指向常量的指针:
#include<iostream>
using namespace std;
void main()

{
const char *name="yuyunliuhen";
name = "lj";
// name[2]='a'; error
}

指向常量的常指针:
#include<iostream>
using namespace std;
void main()

{
const char * const name="yuyunliuhen";
// name = "lj"; //error
// name[2]='a'; //error
}

常指针:
#include<iostream>
using namespace std;
void main()

{
char *const name="yuyunliuhen";
// name = "lj"; //error
name[2]='a';
}

................................................................
5）关于记忆技巧：
对于区分const int *pa和int *const pa这两者，
前者中，const直接修饰*（不考虑int，因为类型在这里是没影响的），说明

*（解引用）这种行为具有常量性，即“不能靠解引用改变它指向的对象的值

”，即指向常量的指针。
后者中，const直接修饰pa，说明pa本身的值具有常量性，即常量指针。

或者也可以这样来记忆：
const int a; // const常量
const int *a; //指向常量的指针
int *const a=&n; //常量指针
你在纸上按顺序写下以上三行，记住它们的注释长度：短——长——短，
分别对应着：const常量、指向常量的指针、常量指针这三种，应该就不会混

淆了。

个人认为以上记忆法比《Effective ++》条款21中推荐的划线分左右法更好

记。

另1：也有教材反过来把上述第二者称呼为“常量指针”，第三者称呼为：“

指针常量”，相对来说更容易让人混淆，大家还是只记住上面的那种称呼法

就好。

另2：const和typedef在一起时容易让人陷入陷阱，具体见《typedef的用途

和陷阱》。

[此贴子已经被作者于2007-3-26 16:59:34编辑过]