4、指针和内容都是不可变的
    const 在星号之后的话，那么 ，就是指向 const 的指针，也就是这个指针指向的地址，不能被改变的，所以，const 指针就必须进行初始化，然后这个地址就是一直被固定住了，不能内改变的。
}


const int *pa;
对于区分const int *pa和int *const pa这两者，
using namespace std;

     
2、指向const的指针
int main(int argc, char *argv[])
    return 0;
int const b=c; // c是已经声明过的整型





const int *const c=&e; //e是已经声明过的整型，整型常量或整型变量都可以
 第一种：首先 P 是一个指针，P所指向的内容（*P）所指向的内容是 const int 类型的。
const int a = 10;  // 正确
    首先是一个指针，只不过这个指针是 const 类型的，也就是这个指针变量的地址，只能在初始化之后，就一直指向这个地址，地址所被保存的内容是可变的。

    首先，这个P 是一个指针，而这个指针是指向了 int 类型的 const 指针。只不过地址是被固定，不能改变，但是地址所保存的数值确实可变的，比如：
后者中，const直接修饰pa，说明pa本身的值具有常量性，即常量指针。
pa =&t; //可行，指向变量t
5）关于记忆技巧：

而且指向常量的指针有时候也会指向变量，如下：
这种形式可以被理解为，p是一个指针，这个指针是指向int 的const指针。它指向的值是可以被改变的如*p=3;
看了上面的内容是不是有点晕，没关系，你不用去背它，用的多了就知道了，还有个技巧，通过上面的观察我们不难总结出一点规律，是什么呢？也许你已经看出来了，什么！竟然没看也来，那只好还得听我唠叨了。这个规律就是： 指向const的指针（指针指向的内容不能被修改）const关健字总是出现在*的左边而const指针（指针本身不能被修改）const关健字总是出现在*的右边，那不用说两个const中间加个*肯定是指针本身和它指向的内容都是不能被改变的。有了这个规则是不是就好记多了。
“常量指针”即指针本身的值是常量，但“能靠解引用改变它指向的对象的值”，如下：
     p4=p5;//不正确 （指针本身和它指向的内容都是不能被改变）

分别对应着：const常量、指向常量的指针、常量指针这三种，应该就不会混淆了。
4）最后，是前面两者的结合：指向常量的常量指针
    顾名思义，就是指针的地址和地址所被保存的内容都是不可变的。

5、理解记忆
const int *p  // 一般使用这个
    int a=3;
    const int* p1;
const int a;  // 错误

或者：
 
前者中，const直接修饰*（不考虑int，因为类型在这里是没影响的），说明*（解引用）这种行为具有常量性，即“不能靠解引用改变它指向的对象的值”，即指向常量的指针。

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

const 本质上被命名为 readonly 更为合适。
int t,u;

    int const* const p5=&b;
int const *p   

const int a; // const常量
int * const p = 地址 // 因为P 所指向的地址是不能被修改的，所以必须被初始化

    这样 ，func 函数将不会修改实参指针所指的数据，但是其他的函数却可以修改他。
pa=& d; // 可行（d是已经声明过的整型）
    const int* const p4=&a;
或者也可以这样来记忆：
int const * const p = 地址值

1）先看const常量的情况：
你在纸上按顺序写下以上三行，记住它们的注释长度：短——长——短，

    /*指针本身和它指向的内容都是不能被改变的所以也得初始化*/
    /*定义const指针(由于指针本身的值不能改变所以必须得初始化）*/

    经过const 修饰的变量，在定义的时候，就要进行初始化。


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

     

const是一个C语言的关键字，它限定一个变量不允许被改变,产生静态作用。const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。

pa=&d; // 不可行（d是已经声明过的整型）
    



*pa =d; // 不可行（d是已经声明过的整型）
     p3=p1; //不正确（指针本身的值不能改变）
先说指向const的指针，它的意思是指针指向的内容是不能被修改的。它有两种写法。
int const* p;
但指针本身的值是可变的：





*pa =d; // 可行（d是已经声明过的整型）
int const* const p=一个地址;

int *const a=&n; //常量指针
    int const* p2;
    一句话， P 这个地址可以随便指，但是地址里面保存的值却是不能改变。

什么还是晕，那就看下面的程序，你把它编译一下看看错误提示就明白了。
    

第二种很容易被理解成是p是一个指向int的const指针（指针本身不能被修改），但这样理解是错误的，它也是表示的是指向const的指针（指针指向的内容是不能被修改的），它跟第一种表达的是一个意思。为了避免混淆推荐大家用第一种。


     *p3=5; //正确
     *p4=*p5=4; //不正确（指针本身和它指向的内容都是不能被改变）

两者都可以。本地的const常量必须在第一次声明时就初始化，用变量或常量初始化都可以，只是初始化一次以后它的值就不能再改变了，此所谓const的含义。
因为常量指针也是一种const常量，所以它同样必须在第一次声明时就初始化，不过它的初始值缩小为只能是变量（的地址），因为只有变量才能确保以后能靠解引用而改变它指向的对象的值。这使得常量指针不象一般的const常量，用变量或常量初始化都可以。

}

    其实就看 const 的位置。const，在指针的星号之前，那么就是指向const 的指针，也就是 *p 的内容是常量，不能被改变。

 
还有一种情况是这个指针本身和它指向的内容都是不能被改变的，请往下看。
第一种可以理解为，p是一个指针，它指向的内容是const int 类型。p本身不用初始化它可以指向任何标示符，但它指向的内容是不能被改变的。
{

3)然后看常量指针的情况：
func(const char *ptr)
{
const int a=2;
    const 关键字最有用的地方是用来限定函数的形参
    一般：

3、const 指针

int* const p=一个地址; (因为指针本身的值是不能被修改的所以它必须被初始化）

当使用带有const的指针时其实有两种意思。一种指的是你不能修改指针本身的内容，另一种指的是你不能修改指针指向的内容。听起来有点混淆一会放个例子上来就明白了。

    可见 P 是一个指针，但是这个指针，前面有 const 进行修饰，所以，这个 P 指针就是一个指针常量，所以 P 的地址就被固定了，所以只能进行初始化了。 而对于 *p 而言，前面又有 const 进行修饰，所以*p 就是一个常量了，也就是 p 指向地址，地址上保存的数据是一个常量，不能被改变的。

把它理解成一个普通的const常量，同时被剥夺了“靠解引用改变它指向的对象的值”的性质的就行。


int const *pa;

    /*定义指向const的指针（指针指向的内容不能被修改）*/
    int b;

const int* p; （推荐）
再说const指针，它的意思是指针本身的值是不能被修改的。它只有一种写法
    


const 指针与指向const的指针
    

1、const 的理解
    
const int* const p=一个地址;


也就是说，常量指针反而总是指向变量的。
    
    int* const p3=&a;
两者也等价。因为指向常量的指针有时候会指向常量，所以它具有这个性质：“不能靠解引用改变它指向的对象的值”，以此保护它所指向的常量的常量性：
 

 
     *p1=*p2=8; //不正确（指针指向的内容不能被修改）



     p1=p2=&a; //正确

const int *pa;

第二种，: 首先 P 也是一个指针，指向的内容是 const int 类型的，也就是所指向的内容是是绝对不能被修改的。
    首先，是一个指针，但是这个指针是指向一个const 类型的指针。
const常量、指向常量的指针和常量指针


const int * const p = 地址值
    
*p = 3;
    const 是C语言（C ）的一个关键字，需要注意的是，const 关键字是把变量变为一个只读的变量，绝对不是将这个变量变为常量。也就是说经过const 修饰的变量成为只读的变量之后，那么这个变量就只能作为右值（只能赋值给别人），绝对不能成为左值（不能接收别人的赋值）。

const int *a; //指向常量的指针
我们可以把它理解成：“为了指向常量而发明的指针”，这样比较贴切。
pa =&u; //也可行，指向变量u