指针的总结

指针
指针变量的定义指针变量的定义及使用
数据类型 *指针名

int *x;
float *f;
char *ch;

指针变量名为 x、f、ch
指针变量的使用
取地址运算符&：单目运算符&是用来取操作对象的地址。例：&i 为取变量 i 的
地址。对于常量表达式、寄存器变量不能取地址（因为它们存储在存储器中，没
有地址）。
指针运算符*（间接寻址符）：与&为逆运算，作用是通过操作对象的地址，获
取存储的内容。例：x = &i，x 为 i 的地址，*x 则为通过 i 的地址，获取 i 的内
容。

//声明了一个普通变量 a
int a;
//声明一个指针变量，指向变量 a 的地址
int *pa;
//通过取地址符&，获取 a 的地址，赋值给指针变量
pa = &a;
//通过间接寻址符，获取指针指向的内容
printf("%d", *pa);

“&”和“”的结合方向
&”和“”都是右结合的。假设有变量 x = 10，则*&x 的含义是，先获取变量 x 的
地址，再获取地址中的内容。因为“&”和“*”互为逆运算，所以 x = *&x。
小练习，输入 x、y 两个整数，然后将其中的值大的赋值给 x，小的赋值给 y。即：
假设输入 x = 8，y = 9。就将 9 赋值给 x，8 赋值给 y。

void main(){
//声明两个普通变量
int x, y;
//声明两个指针变量
int *px, *py;
//声明一个临时变量，用于交换
int t;
//输入两个值，赋值给 x、y
scanf("%d", &x);
scanf("%d", &y);
//给指针变量 px、py 赋初值（关联变量 x、y）
px = &x;
py = &y;
//利用指针来对比 x、y 的值，如果 x 的值比 y 的值小，就交换
if(*px < *py){
//交换步骤，其中*px == x、*py == y
t = *px;
*px = *py;
*py = t;
}
printf("x = %d, y = %d", *px, *py);
}

指针变量的初始化
指针变量与其它变量一样，在定义时可以赋值，即初始化。也可以赋值“NULL”或
“0”，如果赋值“0”，此时的“0”含义并不是数字“0”，而是 NULL 的字符码值。

//利用取地址获取 x 的地址，在指针变量 px 定义时，赋值给 px
int x;
int *px = &x;
//定义指针变量，分别赋值“NULL”和“0”
int *p1= NULL, *p2 = 0;

指针运算
赋值运算
指针变量可以互相赋值，也可以赋值某个变量的地址，或者赋值一个具体的地址

int *px, *py, *pz, x = 10;


//赋予某个变量的地址
px = &x;
//相互赋值
py = px;
//赋值具体的地址
pz = 4000;

指针与整数的加减运算
指针与整数的加减运算
指针变量的自增自减运算。指针加 1 或减 1 运算，表示指针向前或向后移动一
个单元（不同类型的指针，单元长度不同）。这个在数组中非常常用。
指针变量加上或减去一个整形数。和第一条类似，具体加几就是向前移动几个单
元，减几就是向后移动几个单元。

//定义三个变量，假设它们地址为连续的，分别为 4000、4004、4008
int x, y, z;
//定义一个指针，指向 x
int *px = &x;
//利用指针变量 px 加减整数，分别输出 x、y、z
printf("x = %d", *px); //因为 px 指向 x，所以*px = x
//px + 1，表示，向前移动一个单元（从 4000 到 4004）
//这里要先(px + 1)，再*(px + 1)获取内容，因为单目运算符“*”优先级高于双目
运算符“+”
printf("y = %d", *(px + 1)); 
printf("z = %d", *(px + 2));

关系运算
假设有指针变量 px、py。
px > py 表示 px 指向的存储地址是否大于 py 指向的地址
px == py 表示 px 和 py 是否指向同一个存储单元
px == 0 和 px != 0 表示 px 是否为空指针

//定义一个数组，数组中相邻元素地址间隔一个单元
int num[2] = {1, 3};
//将数组中第一个元素地址和第二个元素的地址赋值给 px、py
int *px = &num[0], *py = &num[1];
int *pz = &num[0];
int *pn;
//则 py > px
if(py > px){
printf("py 指向的存储地址大于 px 所指向的存储地址");
}
//pz 和 px 都指向 num[0]
if(pz == px){
printf("px 和 pz 指向同一个地址");
}
//pn 没有初始化
if(pn == NULL || pn == 0){
printf("pn 是一个空指针");
}

指向函数的指针
C 语言中，函数不能嵌套定义，也不能将函数作为参数传递。但是函数有个特性，
即函数名为该函数的入口地址。我们可以定义一个指针指向该地址，将指针作为参
数传递。
数据类型 (*函数指针名)();

#include <string.h>
/**
* 定义一个方法，传入两个字符串和一个函数指针 p，用 p 对两个字符串进行操
作
*/
void check(char *x, char *y, int (*p)());
void main(){
//string.h 库中的函数，使用之前需要声明该函数。字符串比较函数
int strcmp();
char x[] = "Zack";
char y[] = "Rudy";
//定义一个函数指针
int (*p)() = strcmp;
check(x, y, p);
}
void check(char *x, char *y, int (*p)()){
if(!(*p)(x, y)){
printf("相等");
}else{
printf("不相等");
} }

函数的返回值为指针
数据类型 *函数名(参数列表){
函数体
}

//例如：
int s;
int *sum(int x, int y){
s = x + y;
return &s;
}
在函数调用前要声明需要对函数声明
int s;
void mian(){
int *r = sum(10, 9);
printf("10 + 9 + %d", *r);
}
int *sum(int x, int y){
s = x + y;
return &s;
}

指针与数组
指向数组的指针
数组名即为该数组的首地址，结合上面指针和整数的加减，我们就可以实现指针
访问数组元素。

int nums[10], *p;
//数组名即为数组的首地址
p = nums;
//数组第一个元素的地址也是数组的首地址
p = &nums[0];
*p = 1，此操作为赋值操作，即将指针指向的存储空间赋值为 1。此时 p 指向数


组 nums 的第一个元素，则此操作将 nums 第一个元素赋值为 0，即 nums[0] =
1。
p + 1，此操作为指针加整数操作，即向前移动一个单元。此时 p + 1 指向
nums[0]的下一个元素，即 nums[1]。通过p + 整数可以移动到想要操作的元素
（此整数可以为负数）。
如上面，p（p + 0）指向 nums[0]、p + 1 指向 nums[1]、、、类推可得，p+i

指向 nums[i]，由此可以准确操作指定位置的元素。

//定义一个整形数组，并初始化
int nums[5] = {4, 5, 3, 2, 7};
//定义一个指针变量 p，将数组 nums 的首地址赋值给 p，也可以用p =
&nums[0]赋值
int *p = nums, i; //i 作为循环变量
//p 指向数组第一个元素（数组首地址），我们可以直接用间接寻址符，获取第
一个元素的内容
printf("nums[0] = %d\n", *p); //输出结果为 nums[0] = 4
//我们可以通过“p + 整数”来移动指针，要先移动地址，所以 p + 1 要扩起来
printf("nums[1] = %d\n", *(p + 1)); //输出结果为 nums[1] = 5
//由上面推导出*(p + i) = nums[i]，所以我们可以通过 for 循环变量元素
for(i = 0; i < 5; i++){
printf("nums[%d] = %d", i, *(p + i));
}

数组名不等价于指针变量，指针变量可以进行 p++和&操作，而这些操作对于
数组名是非法的。数组名在编译时是确定的，在程序运行期间算一个常量
多级指针

//定义普通变量和指针变量
int *pi, i = 10;
//定义二级指针变量
int **ppi;
//给指针变量赋初值
pi = &i;
//给二级指针变量赋初值
ppi = π
//我们可以直接用二级指针做普通指针的操作
//获取 i 的内容
printf("i = %d", **ppi);
//获取 i 的地址
printf("i 的地址为%d", *ppi);

在初始化二级指针 ppi 时，不能直接 ppi = &&i，因为&i 获取的是一个具体的
数值，而具体数字是没有指针的。
指针数组

//定义一个数组
int nums[5] = {2, 3, 4, 5, 2}, i;
//定义一个指针数组
int *p[5];
//定义一个二级指针
int **pp;
//循环给指针数组赋值
for(i = 0; i < 5; i++){
p[i] = &nums[i];
}


//将指针数组的首地址赋值给 pp，数组 p 的数组名作为 p 的首地址，也作为 p
中第一个元素的地址。
//数组存放的内容为普通变量，则数组名为变量的指针；数组存放的内容为指
针，则数组名为指针的指针。
pp = p;
//利用二级指针 pp 输出数组元素
for(i = 0; i < 5; i++){
//pp == &p[0] == &&nums[0]，nums[0] == *p[0] == **pp
printf("%d", **pp);
//指针变量+整数的操作，即移动指针至下一个单元
pp++;
}

原文链接：https://blog.csdn.net/ZackSock/article/details/101594794