目录
数组指针
指针数组
字符指针数组
二维字符数组
const 修饰变量为常量
指针常量
常量指针
typedef 重命名数据类型
关于typedef的一般理解
具体示例分析
复杂示例分析
总结回顾--指针的奥秘：深入理解内存地址与数据存储
一、指针的本质
二、地址类型转换的意义
数组指针
整型指针 指针指向整型空间
int *p;
数组指针 指针指向数组空间
int (*p)[3]; //本质上是指针
下面是几个例子需要理解
int a[5]; // a==&a[0] 数组名a是首元素a[0]的地址
int *p=a;// p=a
int *p=&a[0];//
int *p = a;和int *p = &a[0];这两种写法是等价的，都是让指针p指向数组a的首元素。此时，a[0]和p[0]是等价的，都表示访问数组的第一个元素。
*(a+1)== *(p+1)//
*(a + 1)和*(p + 1)也是等价的，都表示访问数组的第二个元素。因为a在表达式中会被转换为指针，a + 1指向数组的第二个元素，解引用后得到第二个元素的值；同理，p + 1也指向数组的第二个元素，解引用后得到相同的值。p=a+1; // p=&a[1]此时
p指向数组a的第二个元素
e.g.
int a[5];//定义了一个指向包含 5 个整数的数组
int (*p)[5]=&a; // p=&a，即p指向整个数组
a[0]==(*p)[0]==**p
a[0]、(*p)[0]和**p是等价的。
(*p)表示解引用指针p，得到一个包含 5 个整数的数组，(*p)[0]表示这个数组的第一个元素**p也是先解引用p得到数组，再解引用这个数组的首元素指针得到第一个元素。
a[4] == (*p)[4] == *((*p)+4) == *((int *)(p+1)-1) == *(*(p+1)-1)
a[4]、(*p)[4]、*((*p)+4)、*((int *)(p+1)-1)和*(*(p+1)-1)也是等价的。
(*p)[4]表示解引用p指向的数组的第五个元素*((*p)+4)先解引用p得到数组，再对这个数组的首元素指针加上 4，然后解引用得到第五个元素*((int *)(p+1)-1)先将p + 1转换为指向整数的指针，然后减去 1，再解引用得到数组的最后一个元素*(*(p+1)-1)先解引用p + 1得到一个新的数组（这里实际上是越界访问，但从逻辑上理解），再对这个新数组的首元素指针减 1，解引用得到原数组的最后一个元素。
e.g.
int a[2][3];
int *p=&a[0][0]; //将指针 p 指向二维数组 a 的第一个元素a[0]，即*a 。
a[1][2] == a[0][5] == *(p+5)
因为二维数组在内存中是按行优先存储的，
a[1][2]在内存中的位置相对于a[0][0]正好偏移了 5 个整数的位置。
int (*p)[3]=&a[0]; // 让 p 指向二维数组 a 的第一行a[0]
a[1][2] == *(*(p+1)+2) == (*(p+1))[2] == *(p[1]+2) == p[1][2]
*(p + 1)表示指向二维数组的第二行，*(p + 1)+2表示第二行的第三个元素的指针，解引用得到该元素的值；
(*(p + 1))[2]先解引用p + 1得到第二行数组，再访问第三列的元素；
*(p[1]+2)和p[1][2]也是类似的逻辑。
int (*p)[2][3]=&a;//将 &a赋值给 p，即 p 指向整个二维数组 a
a[1][2] == (*p)[1][2]
(*p)表示解引用指针p，得到二维数组a，(*p)[1][2]表示这个二维数组的第二行第三列的元素。
| 学习理解这部分知识，可以：
从基本概念出发，逐步深入理解
|
指针数组
整型数组 ----数组元素是整型
指针数组 ----数组元素是指针
int *a[5]; //本质上是数组
a[0] a[1] a[2] 都是指针
int *a[2][3];
a[0] a[1] 都是一维指针数组
a[0][0] a[0][1] a[1][1] 都是指针
字符指针数组
char *a[5]={“123”, “abcdef”, “45789”, “zxcvb”, “000123456”};
char b= ‘A’;
a[0]=&b;
a[1]= “123456”; 字符指针指向首字符地址，不能修改字符串的数据
sizeof(a) == 40
定义了一个字符指针数组 a，它包含五个指针，分别指向五个不同的字符串常量。
接着定义了一个字符变量 b，初始化为 'A'。然后让 a[0]指向 b 的地址，此时 a[0]不再指向字符串，而是指向单个字符 b。这就像把原来指向一个字符串物品堆的标签，改指向了单独的一个字符物品。
之后又让 a[1]指向新的字符串常量 “123456”。由于字符串常量在内存中通常是不可修改的，所以虽然指针可以指向不同的字符串，但不能改变字符串常量本身的内容。就像标签可以指向不同的物品堆，但不能改变物品堆里的物品。
这里的两个赋值语句有一定区别：
- 赋值内容不同
a[0]=&b;是让a[0]指向一个字符变量b（存储单个字符）。a[1]= “123456”;是让a[1]指向一个字符串常量（包含多个字符和结束符）。
- 可修改性不同
- 通过
a[0]可以修改b的值。 - 不能修改
a[1]指向的字符串常量内容，否则可能出错。
- 通过
最后，sizeof(a)等于 40，因为在这个环境下指针可能占用 8 个字节，而数组 a 有五个指针元素，所以总共占用 40 个字节。就像一个盒子里装了五个特定大小的东西，通过测量盒子大小可以知道这些东西总共占用的空间。
二维字符数组
定义一个二维字符数组
char a[3][80]={ “123”, “abcdef”, “45789”};
其中a[0] 最多存储 80 个字符
a[1][0]= ‘h’; //数组是变量的集合，可以更改数据
总长度sizeof(a) == 240
const 修饰变量为常量
const int a=5; // a 是只读变量，const修饰谁，谁就是常量
a=6; // 不合法，因为a被声明为const，不能被赋值修改。
int *p=&a;//用一个指向int类型的指针p指向这个const修饰的变量a的地址。
*p = 6; // 合法，通过指针去修改这个地址上的值
指针常量
数字常量 1 值不能改变
指针常量 int * const p; p 被 const 修饰，所以 p 的值不能改变
- int a=5,b=10;
- int * const p=&a;//定义了一个常量指针
p。这里的 “常量指针” 是指指针本身的值（即它所指向的地址）不能被改变，但它所指向的内容可以被改变。- *p=6; // 合法,虽然
p不能指向其他地址，但它所指向的内容是可以修改的。这里通过*p修改了p所指向的变量（即a）的值，将其从5改为6- p=&b; // 不合法,初始化时让
p指向了变量a的地址，之后就不能再让p指向其他变量的地址了
常量指针
整型指针 int *p; 指针指向整型
常量指针 char const *p; 指针指向常量 const 修饰*p，*p 不能改变
const char *p;
- char a=57,b=32;
- char const *p=&a;
//定义了一个指向常量字符的指针
p，并初始化为指向a。这意味着不能通过这个指针来修改它所指向的内容。
- *p=97; // 不合法
//不能通过这个指针来修改p所指向的内容。
- p=&b; // 合法
//不能通过
p修改它所指向的内容，但是可以改变指针p本身的值，让它指向其他的地址
- *p=97; // 不合法
//虽然，现在p指向b，但仍不能通过这个指针来修改p所指向的内容。
- printf(“%d\n”,*p); // 合法
//只是读取
p所指向的内容并输出其对应的整数值，没有尝试修改它所指向的内容
const int *const p; //p 和*p 都是只读
const int *const p，这里有两个const关键字。第一个const修饰int，表示指针所指向的内容是常量。第二个const修饰指针p本身，表示指针p是一个常量，它存储的地址值不能被改变。
- 指针指向的内容只读（
*p）- 另一个
const表示指针指向的变量的值不能被修改。即使p指向了某个变量，也不能通过p来改变这个变量的值。
- 另一个
- 指针本身只读（
p）const修饰指针p，就像把指针 “钉” 在了一个地址上，不能再让它指向别的地方。比如，不能重新给p赋值一个新的变量地址。
typedef 重命名数据类型
关于typedef的一般理解
typedef A B; // A 代表数据类型 B 代表新名称
A m;
B n; //m 和 n 数据类型相同
具体示例分析
typedef int * a;//定义了
a作为int*类型的别名a n; // 等同于
int* n;，即定义了一个指向整数的指针n。int a,*b; // int a; int *b;声明了一个整数变量
a和一个指向整数的指针变量b。int *a,b; // int *a; int b;声明了一个指向整数的指针变量
a和一个整数变量btypedef int * INT;//定义了一个别名
INT代表int*类型。INT a,b; // INT a; INT b; === int *a; int* b;//即声明了两个指向整数的指针变量
a和b。
复杂示例分析
typedef int*(*F[2])[3];
F m; // 等同于
int*(*m[2])[3];，即定义了一个变量m，sizeof(F) == 16
这定义了一个较为复杂的类型别名。F是一个数组类型，这个数组有 2 个元素，每个元素是一个指针，这个指针指向一个包含 3 个整数指针的数组。
从逐步分析这个类型定义：
分析F的长度
- 先看
F，F被定义为一个数组类型，名为F的数组有 2 个元素，即F[2]。 - 接着看每个元素的类型，每个元素是一个指针，所以是
(*F[2])，指针指向的对象是一个包含 3 个元素的数组。 - 最后看这个包含 3 个元素的数组的元素类型，这个数组的元素是指向整数的指针，即
int*，所以完整的类型就是int*(*F[2])[3]，表示F是一个包含 2 个元素的数组，每个元素是一个指针，指向一个包含 3 个指向整数指针的数组。 -
首先看
int*(*)[3]这个类型：- 它表示一个指针，这个指针指向一个包含 3 个指向整数指针（
int*）的数组。 - 在假设指针大小为 8 字节的系统中，这个指针本身占用 8 字节的空间。
- 它表示一个指针，这个指针指向一个包含 3 个指向整数指针（
-
接着看
F的类型：F被定义为int*(*F[2])[3]，这意味着F是一个包含 2 个元素的数组。- 每个元素的类型是前面提到的指向包含 3 个指向整数指针的数组的指针。
- 所以
sizeof(F)就等于 2 倍的这种指针的大小，即2 * sizeof(int*(*)[3])。
所以 sizeof(F) = 2 * sizeof(int*(*)[3]) = 2 * 8 = 16字节。
总结回顾--指针的奥秘：深入理解内存地址与数据存储
在 C 和 C++ 等编程语言中，指针是一个强大而又复杂的概念。它就像是一把钥匙，能够打开内存世界的大门，让我们直接访问和操作计算机内存中的数据。
一、指针的本质
指针的核心作用是保存地址。在计算机内存中，每个数据都存储在特定的空间位置，而这个位置可以用地址来表示。不同类型的指针保存不同类型数据的地址，这意味着指针的类型与它所指向的地址的类型紧密相关。例如，一个指向整数的指针只能保存整数变量的地址，而不能保存其他类型变量的地址。
在定义指针时，我们先确定指针指向的空间变量的类型，然后在变量名前面加上*来表示这是一个指针。例如，int *ptr表示ptr是一个指向整数的指针。当我们使用*解引用指针时，得到的是指针所指向的地址对应的空间变量。
此外，指针的大小通常是固定的，并且与计算机的位数有关。在 32 位系统中，指针通常占用 4 个字节；而在 64 位系统中，指针通常占用 8 个字节。
二、地址类型转换的意义
地址类型转换主要是在转换地址所代表的空间大小。这是因为不同类型的数据在内存中占用的空间大小可能不同。例如，一个整数可能占用 4 个字节，而一个浮点数可能占用 8 个字节。当我们进行地址类型转换时，实际上是在告诉编译器如何解释特定地址上存储的数据。
让我们来看一个具体的例子，在地址 0x8000010002 的位置存储一个浮点型数据
float *p=(float *)0x8000010002;
*p=3.14;
(long)p+2 == 0x8000010004
首先，将地址 0x8000010002 强制转换为 float * 类型指针并赋值给 p，使 p 指向该地址的浮点型数据。接着，用 *p 将 3.14 存储到这个地址。然后看 (long)p + 2，由于指针大小与计算机位数有关，假设系统中指针占 8 字节。将 p 强制转换为 long 类型，是把地址值转为长整型数。而 (long)p + 2 是将地址值加 2 字节，因 long 占 8 字节、float 占 4 字节，加 2 字节相当于指向下一个浮点数地址，此时 (long)p + 2 的值为 0x8000010004。
