改值场景示例

- 改变 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 = 10

return 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)

指针变量的 +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); - 输出 June

print("%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); - 输出 vampire

return 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); - 输出 21

return 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);