C语言-指针类型

2018-10-31  本文已影响0人  VampireJune
- 改变 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;
}

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

- 格式：变量类型 *变量名;
- '*'：指针变量的标识

- 定义一个整型变量
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

指针与字符串

- 这种 字符串 写法，容易被修改
- 称之为：字符串 变量 // 
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 都放在 常量区
- 它们指向的 字符 是 同一个字符

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);
上一篇下一篇

猜你喜欢

热点阅读