《带你学C带你飞学习笔记》—— SE27常量和指针

知识点回顾

1. const 关键字

在 C 语言中，有一种能力可以将变量变成具有常量一样的特性。这就是 —— const 关键字。

在它的修饰下，变量就会失去可修改的特性，也就是变成只读的属性。

const int price = 520;
const char a = 'a';
const float pi = 3.14;

2. 指向常量的指针

万能的指针当然也可以指向被 const 修饰过的变量，这就意味着不能通过指针来修改它所引用的值。

这时候，如果尝试修改指针引用的值，那么我们将被告知程序无法通过编译；但如果只是修改指针的指向，那么编译器并不会阻止你这么做。

#include <stdio.h>

int main(void)
{
        int num = 520;
        const int cnum = 880;
        const int *pc = &cnum;

        printf("cnum: %d, &cnum: %p\n", cnum, &cnum);
        printf("*pc: %d\n, pc: %p", *pc, pc);

        *pc = 1024;  // 尝试修改 *pc 的值，报错
        printf("*pc: %d\n", *pc);

        return 0;
}

这样编译器会报错， [Error] assignment of read-only location ‘* pc’ 但是你可以这样修改

pc = #

总结：

指针可以修改为指向不同的常量
指针可以修改为指向不同的变量
可以通过解引用来读取指针指向的数据
不可以通过解引用修改指针指向的数据

指向非常量的常量指针

指向常量的指针，不能改变的是指针指向的值，但指针本身是可以被修改的。如果要让指针也不可变，那么可以使用常量指针。

同样是使用 const 关键字修饰即可，只是位置稍微发生了变化：

#include <stdio.h>

int main(void)
{
        int num = 520;
        const int cnum = 880;
        int *const p = &num;

        *p = 1024; // 这是可以的
        printf("*p: %d\n", *p);

        p = &cnum; // 这是禁止的
        printf("*p: %d\n", *p);

        return 0;
}

它有如下特性：

指针自身不可以被修改
指针指向的值可以被修改

指向常量的常量指针

就是在刚才的基础上进一步限制，让常量指针指向的值也是常量：

#include <stdio.h>

int main()
{
        int num = 520;
        const int cnum = 880;
        const int *const p = &cnum;

        *p = 1024;
        printf("*p: %d\n", *p);

        p = &cnum;
        printf("*p: %d\n", *p);

        return 0;
}

这样指针自身不能被改变，它所指向的数据也不能通过对指针进行解引用来修改。其实这种霸气十足的限制在平时很少派上用场啦。并且我们发现——如果初始化时，指向的对象不是 const 修饰的变量，那么我们仍然可以通过变量名直接修改它的值：

#include <stdio.h>

int main()
{
        int num = 520;
        const int cnum = 880;
        const int *const p = &num;

        printf("*p: %d\n", *p);

        num = 1024;
        printf("*p: %d\n", *p);

        /*
        *p = 1024;
        printf("*p: %d\n", *p);

        p = &cnum;
        printf("*p: %d\n", *p);
        */

        return 0;
}

总结：

指针自身不可以被修改
指针指向的值也不可以被修改

指向“指向常量的常量指针”的指针

标题看起来似乎挺恐怖的，但其实你只要仔细思考，就不难发现：关于指针的那点事儿，永远都是换汤不换药的把戏

#include <stdio.h>

int main()
{
        int num = 520;
        const int cnum = 880;
        const int *const p = &cnum;
        const int *const *pp = &p;

        printf("pp: %p, &p: %p\n", pp, &p);
        printf("*pp: %p, p: %p, &cnum: %p\n", *pp, p, &cnum);
        printf("**pp: %d, *p: %d, cnum: %d\n", **pp, *p, cnum);

        return 0;
}

0. const 修饰的只读变量必须在定义的同时初始化，想想为什么？
   答：定义的时候不初始化的话，后面不能为其赋值，也就不发使用了。
   因为 const 修饰的变量具有只读的特性，一旦生成变无法被改变，所以如果没有在定义的时候对它进行初始化，那它就失去了存在的意义

1. 请问 const int *a; 和 int const *a; 两种写法表示的含义一样吗？
   答：一样；
   因为没有用 const 修饰 * 这样的解释，所以这两种写法表示的含义其实是一样的，都是表示 const int * a;（一个指向 const int 类型的指针）。a 所指向的内存单元为只读，所以 (*a)++ 是不允许的；但指针 a 本身可以修改，即 a++ 是允许的。

2. 错误代码

……
        const int num = 520;
        int *p = #
……

答：只有 A 是错误的做法！在赋值、初始化或参数传参的过程中，赋值号左边的类型应该比右边的类型限定更为严格，或至少是同样严格。在 A 中，使用指针 p，就可能间接地绕过 const 设定的防线

3. 请问下边代码为什么在小甲鱼的编译系统中不能通过编译？如果不改变 p 变量的类型，应该如何改正？

#include <stdio.h>

int main()
{
        int num = 520;
        void *p;

        p = &num;
        printf("%d\n", *p);

        return 0;
}

答：因为 void 指针是可以指向任何类型，所以从另一个角度来看，void 指针“只保存地址，而没有记录跨度。
应该将 p 先强制转换成 int * 类型，再对其进行解引用：（强制类型转换指针类型应该使用（int *））

#include <stdio.h>

int main()
{
        int num = 520;
        void *p;

        p = &num;
        printf("%d\n", *(int *)p);

        return 0;
}

4. 请问下面代码可以成功通过编译并运行吗？

#include <stdio.h>

int main()
{
        const int num = 520;
        int *p = &num;

        printf("num = %d\n", num);

        *p = 1024;
        printf("num = %d\n", num);

        return 0;
}

答：此代码不能通过编译，见上面那题。

因为 const 其实只是对变量名（num）起到一个限制作用，也就是说你不可以通过这个变量名（num）修改它所在的内存通过指针进行间接修改。但是，这并不是说这块内存就不可以修改了，如果你可以通过其他形式访问到这块内存，还是可以进行修改的。所以，尽管编译器发现苗头不对，但它也只能义务地提醒你而已。

6. 请问在下边声明中，const 限制的是 q、*q 还是 **q？

#include <stdio.h>

int main(void)
{
        const int num = 520;
        const int * const p = &num;
        const int * const *q = &p;

        ……

        return 0;
}

答：const 限制的是 *q 和 **q。
分析：千万不要给乱七八糟的 const 给弄晕了，记住一点：const 永远限制紧随着它的标识符。const int * const *q = &p; 相当于 (const int) * (const *q) = &p;，即第一个 const 限制的是 **q 的指向，第二个 const 限制的是 *q 的指向，唯有一个漏网之鱼 —— q 没有被限制。

7. 接上题，如果想要使用 const 同时限制 q、*q 和 **q，应该怎么做？.
   答：声明应该写成：const int * const * const q = &p;

8. 请问 const int * const *q; 和 cosnt int const **q; 有何区别？
   答：const int * const *q; 限制了 *q 和 **q 的指向，而 cosnt int const **q; 只限制了 **q 的指向。

动动手
请编写一个程序，测试一下你当前的计算机是大端还是小端？

#include <stdio.h>

int main(void)
{
        int num = 0x12345678;
        unsigned char *p = (unsigned char *)&num;

        if (*p == 0x78)
        {
                printf("您的机器采用小端字节序。\n");
        }
        else
        {
                printf("您的机器采用大端字节序。\n");
        }

        printf("0x12345678 在内存中依次存放为：0x%x 0x%x 0x%x 0x%x\n", p[0], p[1], p[2], p[3]);

        return 0;
}