C语言-指针类型 C语言-指针类型

改值场景示例

- 改变 n 的值的函数 void change(int n) { n = 10; }int main() { int a = 20; - 这里只能把变量a 的值传到 change() 函数里面去 change(a); - 如果想要修改变量a 的值, 就不能只单单将变量a 的值传过去 - 而是将变量a 的地址传过去 - &：取地址符:) - 但是 change() 函数不支持传地址，只能接受 int 类型的值 - 只有指针变量才能接收地址 - 利用指针变量，接收地址，根据地址找到变量a 的存储空间，把它的值改掉printf("a = %d \n",a); return 0; }

指针就一个作用：能够根据一个地址值，访问对应的存储空间

定义指针变量 [作用：取值和赋值]
- 指针变量：只能存储地址
- 指针变量占据 8 个字节
- *：指针运算符
  - 定义指针变量时：仅仅是一个象征，代表定义一个指针变量
  - 赋值时：代表访问指针变量指向的存储空间

- 格式：变量类型 *变量名; - '*'：指针变量的标识- 定义一个整型变量 int a; - 定义一个 int *p; - 这个时候的 '*' 是个象征，代表这个类型是个指针 - 可以看做 'int *' 是一起的 // 强调 int *p; *英文名 point指针 - 指针变量只能存储地址a = 30; - 这样写不合理, 指针变量p 只能存储地址，变量a 把值 30 给指针变量p p = a; - 把变量a 的地址给了指针变量p - &：取地址符 :) - 专业术语：指针变量p 指向了变量a p = &a; - 访问指针变量p 指向的存储空间 *p- 这个时候的 '*' 代表访问指针变量p 指向的存储空间 // 强调 - 把 10 赋值给指针变量p 指向的存储空间 *p = 10; - 这句代码，利用 *p 访问了指针变量p 指向的存储空间 - 然后把 10 赋值给 *p 找到的这块存储空间 - 就把变量a 的值改为了 10；printf("a = %d \n",a); // 输出是 a = 10- 改变量a 的值，打印 *p 的值 a = 30; printf("%d \n", *p); // 输出是 30- 指向 char 类型 char c = 'A'; char *cp = &c; *cp = 'D'; printf("%c \n", *cp); // 输出是 D printf("%c \n", *c); // 输出是 D

指针注意点

*p = 10; - 这样写就是赋值- 这样写就是取值 printf("%d \n", *p); - 这个指针变量p只能指向整型类型的变量 int *p; - 这个指针变量p只能指向 double类型的变量 double *p; - 不建议的写法，int *p 只能指向 int类型的数据 int *p; double d = 10.0; p = &d; - 不建议的写法- 指针变量只能存储地址 int *p; p = 200; - 错误写法- 指针变量未经过初始化，不要拿来间接访问其他存储空间 int *p; printf("%d \n", *p); - 错误写法- 错误写法 *p = &a; - 错误写法- 可以这样直接定义时访问 int *p = &a;

指针定义时为什么要指定类型

就是为了 取值、赋值
不指定，就会数据错乱
用什么样的类型定义指针，那么用指针访问变量存储空间时，就会取值这个类型相应的字节数据
一字节等于八位 :)

- 例如，定义一个 int 类型的变量a，和一个 char 类型的变量c，并赋初始值 int a = 2; // 0000 0000 0000 0000 0000 0000 0000 0010 // 二进制 4个字节 - int 占据 4 个字节，一字节等于八位，二进制就是 4 * 8 = 32 位char c = 1; // 0000 0001 // 二进制 1个字节 - char 占据 1 个字节，一字节等于八位，二进制就是 1 * 8 = 8 位- 变量a 在内存中的存储占4个字节，变量c 占1个字节 - 在内存中是这样排布的，存储的数据是二进制 - 先定义的变量，其存储空间优先分配，且在最下方 - 一行代表一个字节- 如果定义 int 类型的指针变量取变量c 的值 int *p = &c; c 0000 0001 // 取到这里 a 0000 0010 0000 0000 0000 0000 // 从这里开始取值 0000 0000- 那么就是从变量c 的存储地址处，取 8 个字节的数据 - 从下往上取值，先进后出，按二进制的书写格式，取出来就是这样的数据 - 二进制：0000 0000 0000 0000 0000 0010 0000 0001 - 换算成十进制：513；printf(" *p %d \n", *p); // 输出是 513 printf("c %d \n", c); // 输出是 1- 所以指针定义为什么要指定类型 - 就是为了 `取值`、`赋值` - 不指定，就会数据错乱

重新实现开头改值场景示例

void change(int *n) { *n = 10; }int main() { int a = 20; change(&a); printf("a = %d \n",a); // 输出是 a = 10return 0; }

指向指针的指针，以此类推，基本不常见

int a = 10; int *p = &a; (int *) *pp = &p; - 修改变量a 的值 1. a = 20; 2. *p = 20; - 这里是 '==' 表示左右是一样的相同的 3. *pp == p; *(*pp) == *p = a; **pp == *p = a; - 这里是 '==' 表示左右是一样的相同的- 修改指针变量p 指向的变量a 的值 20 **pp = 20; printf("a = %d \n",a); // 输出是 a = 20

文章图片
指向指针的指针.png 输出格式符

文章图片
输出格式符.png 指针与数组

数组名就是数组的地址，也是数组首元素的地址

int nums[5] = {11, 25, 3, 94, 5}; nums[0]; - 访问首元素 &nums[0]; - 取出首元素的地址- 定义一个 int 类型的指针变量p int *p; - 指针变量p 指向了数组的首元素 p = &nums[0]; - 数组名就是数组的地址，也是数组首元素的地址 - 可以直接赋值给指针变量p p = ages; printf(" %d \n",*p); // 输出是 11- 现在指针变量p 存储的是 nums 数组首元素的地址 - 指针变量的 +1 表示，（p + 1）指向 nums 数组第二个元素的地址，地址值 +4 - 并不是地址值 +1，而是取决于指针的类型，int 占据 4 个字节 p + 1; /* + 0 可以不写，为了看着舒服 :) p + 0 ---> &nums[0] p + 1 ---> &nums[1] p + 2 ---> &nums[2] p + i ---> &nums[i] */printf(" %p \n",p); printf(" %p \n",p+1); printf(" %p \n",p+2); - 这就意味着，可以通过指针变量p，间接算出数组后面元素的地址，取出相应的值printf(" %d \n",*(p + 1)); // 输出是 25 printf(" %d \n",*(p + 2)); // 输出是 3- 利用指针遍历数组的值 for (int i = 0; i < 5; i++){ printf(" nums[%d] = %d \n", i, *(p + i)); }- 还可以把指针当做数组来用 - 因为把数组地址给了指针变量p - 相当于把数组名给了指针变量p printf(" %d \n",p[2])); // 输出是 3

数组元素的访问方式
1 > 数组名[下标] nums[i]
2 > 指针变量名[下标] p[i]
3 > *(p + i)
【C语言-指针类型】指针变量的 +1，地址值究竟加多少，取决于指针的类型
1 > int * 4
2 > char * 1
3 > double * 8

指针与字符串

C语言的内存分为 3 大块
- 常量区：存放一些常量字符串（里面东西不能改）
- 堆：存放对象
- 栈：存放局部变量（C语言数组放在栈里面）

- 这种字符串写法，容易被修改 - 称之为：字符串变量 // char name[] = "june"; name[0] = 'J'; printf(" %s \n", name); // 输出是 June- 称之为：字符串常量 // - "June" == 'J' + 'u' + 'n' + 'e' + '\0' char *name2 = "June"; - 指针变量name2 指向了字符串的首字符printf(" %c \n", *name2); // 输出是 J- 这样不可修改 *name2 = 'J'; printf(" %s \n", name2); // 程序崩溃:)char *name3 = "June"; printf(" %p %p \n", name2, name3); //输出地址相同 - 说明 name2 和 name3 都放在常量区 - 它们指向的字符是同一个字符

总结：定义字符串的 2 种方式

1. 利用数组：char name[] = "June"; - 特点：字符串里面的字符是可以修改的 - 使用场合：字符串内容需要经常修改2. 利用指针：char *name = "June"; - 特点：字符串其实是一个常量字符串，里面的字符不能修改 - 使用场合：字符串内容不需要修改，而且这个字符串经常使用** 频繁的开辟存储空间和销毁，非常消耗性能**

指针数组

- 整型数组 int ags[3]; - 指针数组（字符串数组）：里面存放的都是指针，每个指针都有自己指向的字符 char *names[3] = {"Vampire", "June", "VampireJune"}; - 二维字符数组（字符串数组） char name2[2][10] = {"Vampire", "June"};

字符串输入

char name[20]; print("请输入姓名：\n"); - 数组名就是数组的地址 scanf("%s", name); - 输入 June- scanf 本质 - 从 name 的地址开始，一个一个存放输入的字符，并且会在最后补上一个 '\0'- 'J' 'u' 'n' 'e' '\0' print("刚刚输入姓名：%s \n", name); - 输出 Juneprint("%c \n", name[3]); - 输出 e

返回指针的函数

- 返回 char 类型的数据 char june() { return 'J'; }- 返回 char * 类型的数据 - 返回指针的函数 char *vampire() { return "vampire"; }int main() { char *name = vampire() print("name = %s \n", name); - 输出 vampirereturn 0; }

指向函数的指针

函数也有自己的内存地址
函数名 就是函数的 内存地址

- vampire 函数有自己的内存地址 void vampire() { printf("调用了vampire函数 \n"); }- main 函数有自己的内存地址 int main() { - (*p)：固定写法 - 代表指针变量p 将来肯定指向函数 - 左边的 void：代表指针变量p 指向的函数没有返回值 - 右边的()：代表指针变量p 指向的函数没有形参 void (*p)(); - p 等于函数的地址； - 指针变量p 指向了 vampire 函数 p = vampire; - 直接调用函数 p(); - 取出并调用 vampire 函数 - 利用指针变量间接调用函数 (*p)(); - 直接调用函数 vampire(); return 0; }

进阶 - 指向函数的指针

int sum(int vampire, int june) { return vampire + june; }int main() { - 定义指针变量p 指向 sum 函数 - 左边的 int：代表指针变量p 指向的函数返回 int 类型的数据 - 右边的(int, int)：代表指针变量p 指向的函数有 2 个 int 类型的形参 int (*p)(int, int); p = sum; - 3 种函数调用方式 int v = p(10, 11); int v = (*p)(10, 11); int v = sum(10, 11); printf("v = %d \n",v); - 输出 21return 0; }double vampireJune(double d, char *s, int b) {}- 定义指向 vampireJune 函数的指针 double(*p1)(double, char *, int) = vampireJune; - 调用 double v = vampireJune(2.3, "Vampire", 10); double va = (*p1)(2.3, "June", 10); double vam = p1(2.3, "VampireJune", 10);