- 改值场景示例
- 改变 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);
