菜单导航
一、指针变量
/* 1、定义 普通变量: 数据类型 变量名称 指针变量: 数据类型 * 变量名称; 2、指针变量是什么类型,那么将来就只能保存什么类型变量的地址, 例如 指针变量是int类型, 那么将来就只能保存int类型变量的地址 3、* : 标示这是一个指针变量，代表访问指针变量指向的那一块存储空间 4、指针变量只能存储地址 */ int num = 10; char c = 'a'; float f = 12.f; double d = 22.5; printf("num地址：%p, c地址：%p, f地址：%p, d地址：%p \n", &num, &c, &f, &d); printf("num字节: %zu， c字节：%zu, f字节：%zu, d字节：%zu \n", sizeof(num), sizeof(c), sizeof(f), sizeof(d)); int *pNum = # char *pC = &c; float *pF = &f; double *pD = &d; printf("pNum地址：%p, pC地址：%p, pF地址：%p, pD地址：%p \n", &pNum, &pC, &pF, &pD); printf("pNum字节: %zu, pC字节：%zu, pF字节：%zu, pD字节：%zu \n", sizeof(pNum), sizeof(pC), sizeof(pF), sizeof(pD)); printf("改之前的值-->num: %d, c: %c, f: %f, d: %lf \n", num, c, f, d); *pNum = 111; *pC = 'c'; *pF = 222.5f; *pD = 333; printf("改之后的值-->num: %d, c: %c, f: %f, d: %lf \n", num, c, f, d); /** 打印日志 //2, 1, 0, f, e, d, c, b, a, 9, 8, 7 num地址：0x7fff5fbff758, c地址：0x7fff5fbff757, f地址：0x7fff5fbff750, d地址：0x7fff5fbff748 num字节: 4， c字节：1, f字节：4, d字节：8 pNum地址：0x7fff5fbff740, pC地址：0x7fff5fbff738, pF地址：0x7fff5fbff730, pD地址：0x7fff5fbff728 pNum字节: 8, pC字节：8, pF字节：8, pD字节：8 改之前的值-->num: 10, c: a, f: 12.000000, d: 22.500000 改之后的值-->num: 111, c: c, f: 222.500000, d: 333.000000 */
指针变量的应用练习1：交换两个变量的值
#include <stdio.h> /** 交换变量值：地址传递 */ void swop2(int *v1,int *v2) { int temp = *v1; *v1 = *v2; *v2 = temp; } /** 交换变量值：值传递 */ void swop(int v1,int v2) { int temp = v1; v1 = v2; v2 = temp; } int main() { int a = 20, b = 30; //定义两个int类型变量 printf("交换前a: %i, b: %i \n", a, b); //要求交换变量a和b的值 //第一种尝试：传入变量a和b的变量名，在函数内部交换两个变量的值 swop(a, b); printf("。。。传入变量名调用函数交换变量值: \n"); printf("交换后a: %d, b: %d \n", a, b); //第二种尝试: 传入变量a和b的地址，在函数内部交换两个变量的值 swop2(&a, &b); printf("。。。传入变量地址调用函数交换变量值：\n"); printf("交换后a: %d, b: %d\n", a, b); /** 打印结果： 交换前a: 20, b: 30 。。。传入变量名调用函数交换变量值: 交换后a: 20, b: 30 。。。传入变量地址调用函数交换变量值： 交换后a: 30, b: 20 */ printf("\n"); return 0; }
指针变量的应用练习2：一个函数传入3个变量，求返回三个变量的和和平均值
#include <stdio.h> /** 传入3个int变量，求3个变量之和 与 平均值 */ int getSum(int v1, int v2, int v3, int *ave){ int sum = v1 + v2 + v3; *ave = sum/3; return sum; } int main() { int v1 = 18, v2 = 998, v3 = 188; int ave; //存储平均值 int sum = getSum(v1, v2, v3, &ave); printf("v1: %d, v2: %d, v3: %d, 和sum: %d, 平均值ave: %d \n", v1, v2, v3, sum ,ave); //打印结果： v1: 18, v2: 998, v3: 188, 和sum: 1204, 平均值ave: 401 printf("\n"); return 0; }
指针变量注意点：
//1、指针只能保存地址 int num = 10; //int *p = num; //printf("p: %i \n", *p); //这样运行会挂 //2、同一个变量可以有多个指针指向它 int *p = # int *p2 = # printf("num: %d, *p: %i, *p2: %d \n", num, *p, *p2); *p2 = 88; printf("改后num: %d, *p: %i, *p2: %d \n", num, *p, *p2); /** 打印日志： num: 10, *p: 10, *p2: 10 改后num: 88, *p: 88, *p2: 88 */ //3、指针的指向可以修改 int num2 = 18; p2 = &num2; *p2 = 99; printf("num: %d, *p: %d, *p2: %d, num2: %d \n", num, *p, *p2, num2); //打印日志：num: 88, *p: 88, *p2: 99, num2: 99 //4、不要访问野指针：野指针值没有赋值的指针 int *p3 = NULL; //*p3 = 12; //这样运行会挂
// 5、指针变量和变量类型要一致，即int类型指针只能存储int类型的变量的地址
// 因为当我们利用指针去取值的时候,系统会自动根据指针的类型来确定应该取对少个字节的值. int intValue = 518; char *p = &intValue; printf("*p: %i \n", *p); /** 打印日志：*p: 6 为什么？ intValue = 518 的二进制为： 0000 0000 0000 0000 0000 0010 0000 0110 指针变量p是char类型，只会存储char类型的地址，即一个字节的地址， 所以指针变量p只存储了intValue的最小字节地址，即0000 0110这个字节的地址，转成十进制为：6 */
多级指针测试：
//一级指针 char ch = 'a'; char *p = &ch; *p = 'b'; printf("c: %c, *p: %c \n", ch, *p); //打印日志：c: b, *p: b //二级指针 char **p2 = &p; //指向指针的指针，也占用8个字节 **p2 = 'd'; printf("ch: %c, *p: %c, **p2: %c \n", ch, *p, **p2); //打印日志：ch: d, *p: d, **p2: d //三级指针 char ***p3 = &p2; ***p3 = 'f'; printf("ch: %c, *p: %c, **p2: %c, ***p3: %c \n", ch, *p, **p2, ***p3); //打印日志：ch: f, *p: f, **p2: f, ***p3: f printf("地址--》ch: %p, p: %p, p2: %p, p3: %p \n", p, p2, p3, &p3); //打印日志：地址--》ch: 0x7fff5fbff76b, p: 0x7fff5fbff760, p2: 0x7fff5fbff758, p3: 0x7fff5fbff750
二、指针和数组
//指针和数组 int arr[] = {88, 18, 58}; int *pi = arr; //arr是数组名，也是数组地址，也是数组中第一个元素的地址 printf("arr: %p, pi: %p, arr[0]: %p \n", arr, pi, &arr[0]); //打印日志：arr: 0x7fff5fbff760, pi: 0x7fff5fbff760, arr[0]: 0x7fff5fbff760 //pi + 1 : 表示地址+1，本质是地址+该数据类型的字节个数; pi相当于数组名 printf("pi+1: %p, arr+1: %p \n", pi+1, arr+1); printf("*(pi+1): %i, *(arr+1): %i, pi[1]: %i, arr[1]: %i \n", *(pi+1), *(arr+1), pi[1], arr[1]); /** 打印日志： pi+1: 0x7fff5fbff764, arr+1: 0x7fff5fbff764 *(pi+1): 18, *(arr+1): 18, pi[1]: 18, arr[1]: 18 */ //字符指针和字符数组 char cArr[] = {'a', 'B', 'c', 'D', '\0'}; char *pc = cArr; printf("cArr: %p, pc: %p, cArr[0]: %p \n", cArr, pc, &cArr[0]); printf("pc+1: %p, cArr+1: %p \n", pc+1, cArr+1); printf("*(pc+1): %c, *(cArr+1): %c, pc[1]: %c, cArr[1]: %c \n", *(pc+1), *(cArr+1), pc[1], cArr[1]); *(pc+1) = 'Z'; printf("*(pc+1): %c, *(cArr+1): %c, pc[1]: %c, cArr[1]: %c \n", *(pc+1), *(cArr+1), pc[1], cArr[1]); /** 打印日志： cArr: 0x7fff5fbff743, pc: 0x7fff5fbff743, cArr[0]: 0x7fff5fbff743 pc+1: 0x7fff5fbff744, cArr+1: 0x7fff5fbff744 *(pc+1): B, *(cArr+1): B, pc[1]: B, cArr[1]: B *(pc+1): Z, *(cArr+1): Z, pc[1]: Z, cArr[1]: Z */
三、常量指针和指向常量的指针
先来看几个变量，各自说说他们的区别和时什么类型的变量：
const int a1; //常量a1 int const a2; //常量a2, 这种写法和常量a1的写法是等效的关系 const int *a3; //指向整型常量的指针： 所指向的目标为常量（不能间接修改指向变量的值，可以从新赋值新地址） int * const a4; //a4和a3 不同，a4是常量指针，指向整型的常量指针，即指针是常量
//（可以间接修改指向变量的值，但是不可重新赋值新变量地址） const int * const a5; //a5是指向整型常量的常量指针（既不能间接修改变量的值，也不可重新赋值新变量地址）
总结：1、const关键字写在数据类型的前面和后面是等效关系；
2、指向常量的指针：不能间接修改所指向变量的值，但是可以给指针重新赋值新地址
3、常量指针：可以间接修改指向变量的值，但是不能重新赋值新变量地址
4、指向常量的常量指针：有2个const修改，既不能间接修改变量的值，也不可重新赋值新变量地址
验证示例代码：
//1、指针变量，指针变量可间接修改值，指针变量也可重新赋值新变量地址 int a = 50, a2 = 22; int *ap = &a; *ap = 12; printf("测试1：a=%d, a地址：%x, *ap=%d, ap地址：%x, ap保存的地址：%x \n", a, &a, *ap, &ap, ap); printf("变量a占用字节个数：%lu, 变量ap占用字节个数：%lu \n", sizeof(a), sizeof(ap)); //测试1：a=12, a地址：5fbff65c, *ap=12, ap地址：5fbff650, ap保存的地址：5fbff65c //变量a占用字节个数：4, 变量ap占用字节个数：8 //验证一个问题：a占用的字节地址为5fbff65f-5fbff65c, ap占用的字节地址为：5fbff657-5fbff650 *ap = 13; printf("测试2：a=%d, a地址：%x, *ap=%d, ap地址：%x, ap保存的地址：%x \n", a, &a, *ap, &ap, ap); //测试2：a=13, a地址：5fbff65c, *ap=13, ap地址：5fbff650, ap保存的地址：5fbff65c ap = &a2; printf("*ap=%d, a2=%d, &a2=%x, ap=%x \n", *ap, a2, &a2, ap); //*ap=22, a2=22, &a2=5fbff658, ap=5fbff658 //说明指针变量可以重新指向其他变量 //2、测试指向整型常量的指针 int c = 19, c2 = 29; int const *cp = &c; //指向整型常量的指针 printf("c1: c=%d, *cp=%d, &c=%x, cp=%x \n", c, *cp, &c, cp); //c1: c=19, *cp=19, &c=5fbff63c, cp=5fbff63c // *cp = 20; //报错：Read-only variable is not assignable //指向整形常量的指针，不能间接修改变量的值，因为指向整型常量 c = 20; //但是原变量自己可以直接修改自己的值 printf("c2: c=%d, *cp=%d, &c=%x, cp=%x \n", c, *cp, &c, cp); //c2: c=20, *cp=20, &c=5fbff63c, cp=5fbff63c cp = &c2; printf("c3: c2=%d, *cp=%d, &c2 = %x, cp=%x \n", c2, *cp, &c2, cp); //c3: c2=29, *cp=29, &c2 = 5fbff638, cp=5fbff638 //3、测试指向整型的常量指针 int d = 31, d2 = 32; int* const dp = &d; printf("d1: d=%d, *dp=%d, &d=%x, dp=%x \n", d, *dp, &d, dp); //d1: d=31, *dp=31, &d=5fbff63c, dp=5fbff63c *dp = 3; printf("d2: d=%d, *dp=%d, &d=%x, dp=%x \n", d, *dp, &d, dp); //d2: d=3, *dp=3, &d=5fbff63c, dp=5fbff63c // dp = &d2; //报错：Cannot assign to variable 'dp' with const-qualified type 'int *const' //指向整型的常量指针，不能再重新赋值其他变量地址。但是可以间接修改当前指向的变量的值 //4、测试指向整型常量的常量指针：既不能间接修改变量的值，也不能重新赋值新的变量地址 int e = 41, e2 = 42; int const * const ep = &e; // *ep = 48; //报错：Read-only vaiable is not assignable // ep = &e2;//报错：Cannot assign to variable 'ep' with const-qualified type 'int *const' //5、指向常量的指针变量 int const b = 50; // // b = 30; //编译报错：Cannot assign to variable 'b' with const-qualified type 'const int' int *bp = &b; printf("b=%d, b地址: %x, bp保存的地址：%x, *bp: %d \n", b, &b, bp, *bp); //b=50, b地址: 5fbff64c, bp保存的地址：5fbff64c, *bp: 50 *bp = 88; printf("修改后b=%d, b地址: %x, bp保存的地址：%x, *bp: %d \n", b, &b, bp, *bp); //修改后b=50, b地址: 5fbff64c, bp保存的地址：5fbff64c, *bp: 88 /* 这个地方有点奇怪，b是常量，指针变量bp指向b, 间接通过指针bp修改变量的值， 但是最后打印结果是：*bp的值变了，b的值没有变（b是常量，指针变量bp指向b), 而且bp保存的地址和b的地址还是保持一样 这究竟是为啥？怎么理解 ？ 变量被const修饰时，就复制了其值出来放到常量表中（由系统维护） 但是每次取常量时，它是从常量表找到以前的值，而不是再次读内存。 而指针变量bp可以修改指向地址里面的值。 不知这样理解是否正确？ */