C语言学习系列--＞看淡指针（1）-阿里云开发者社区

一、概述

在大学的宿舍里，每个宿舍都有属于自己的编号（比如：222），每一栋楼也有属于自己名字或者编号（比如：慧苑，B05）。通过这些编号，我们在点外卖的时候，直接将宿舍楼和宿舍号写在地址上，外卖小哥就会将你所点的食物送到对应的宿舍。如果，没有这些编号，你该怎么直接描述地址呢？让小哥一个一个找吗？效率低。

在计算机中，也和上述案例一样。

计算上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存是8GB/16GB/32GB等，那这些内存空间如何⾼效的管理呢？

其实也是把内存划分为⼀个个的内存单元，每个内存单元的⼤⼩取1个字节。

补充：关于计算机中常见的单位：

bit - ⽐特位
byte - 字节
KB
MB
GB
TB
PB

1byte = 8bit
1KB = 1024byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB

每个内存单元就相当于一个学生的宿舍，1个字节里面8个比特位，就相当于一个宿舍里面住了8个学生。

每个内存单元都有对应的编号，相当于每个宿舍都有自己的宿舍号，有了这个内存单元的编号，CPU就可以快速找到⼀个内存空间。

⽣活中我们把⻔牌号也叫地址，在计算机中我们把内存单元的编号也称为地址。C语⾔中给地址起了新的名字叫：指针。

于是，你可以这么理解：内存的编号 = 地址 = 指针

二、指针变量和地址

2.1 取地址操作符

“ & ” 这个符号，在前面scanf（）函数中我们遇到过，是取地址符号

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
  int a = 10;
  &a;
  printf("%p\n", &a);
  return 0;
}

会打印处理：006FFD70

&a取出的是a所占4个字节中地址较⼩的字节的地

址。

虽然整型变量占⽤4个字节，我们只要知道了第⼀个字节地址，顺藤摸⽠访问到4个字节的数据也是可⾏的。

2.2 指针变量和解引用操作符

2.2.1 指针变量

0x006FFD70，这个数值有时候也是需要存储起来，⽅便后期再使⽤的

一般存在指针变量中

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
  int a = 10;
  int* pa = &a;//取出a的地址并存储到指针变量pa中
  return 0;
}

指针变量也是一种变量，只不过这种变量是用来存放地址的

2.2.2 拆解指针类型

int a = 10;
int * pa = &a;

这⾥pa左边写的是 int* ， * 是在说明pa是指针变量，⽽前⾯的 int 是在说明pa指向的是整型(int)类型的对象。

char ch = 'w';
pc = &ch;
char *pc = &ch;

2.2.4 解引用操作符

我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，这⾥必须学习⼀个操作符叫解引⽤操作符(*)。

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
  int a = 100;
  int* pa = &a;
  *pa = 0;
  return 0;
}

*pa 的意思就是通过pa中存放的地址，找到指向的空间，*pa其实就是a变量了；所以==*pa = 0==，这个操作符是把a改成了0.

2.3 指针变量的大小

指针变量的⼤⼩取决于地址的⼤⼩

32位平台下地址是32个bit位（即4个字节）

64位平台下地址是64个bit位（即8个字节）

注意指针变量的⼤⼩和类型是⽆关的，只要指针类型的变量，在相同的平台下，⼤⼩都是相同的。

#include <stdio.h>
int main()
{
  printf("%zd\n", sizeof(char*));
  printf("%zd\n", sizeof(short*));
  printf("%zd\n", sizeof(int*));
  printf("%zd\n", sizeof(double*));
  return 0;
}

三、指针变量的意义

既然指针变量在同一环境下的大小都一样，难么还有意义吗？

3.1 指针的解引用

//代码1
#include <stdio.h>
int main()
{
 int n = 0x11223344;
 int *pi = &n; 
 *pi = 0; 
 return 0;
}

//代码2
#include <stdio.h>
int main()
{
 int n = 0x11223344;
 char *pc = (char *)&n;
 *pc = 0;
 return 0;
}

调试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将n的第⼀个字节改为0。

结论：指针的类型决定了，对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节）。

⽐如： char* 的指针解引⽤就只能访问⼀个字节，⽽ int* 的指针的解引⽤就能访问四个字节。

指针±整数

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
  int n = 10;
  char* pc = (char*)&n;
  int* pi = &n;
  printf("%p\n", &n);
  printf("%p\n", pc);
  printf("%p\n", pc + 1);
  printf("%p\n", pi);
  printf("%p\n", pi + 1);
  return 0;
}

运行结果：

我们可以看出， char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。

这就是指针变量的类型差异带来的变化。

结论：指针的类型决定了指针向前或者向后⾛⼀步有多⼤（距离）。

四、 const修饰指针

const 修饰变量，使得这个变量不能被修改

const 修饰指针

const放在*的左边
限制的是指针指向的内容，意思是不能通过指针来修改指针指向的内容，但是指针变量本身是可以修改的

const放在*的右边
限制的是指针变量本身，意思是不能修改指针变量的指向，但是可以修改指针指向的内容

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h> 
int main() {
    int a = 10;
    int b = 10;
    const int* p1 = &a;
    p1 = &b; //正确
    //*p1 = 100;  报错
    printf("const修饰的是指针时，指针指向可以改，指针指向的值不可以更改\n");
    int* const p2 = &a;
    //p2 = &b; //错误
    *p2 = 100; //正确
    printf("const修饰的是常量时，指针指向不可以改，指针指向的值可以更改\n");
    //const既修饰指针又修饰常量
    const int* const p3 = &a;
    //p3 = &b; //错误
    //*p3 = 100; //错误
    printf("const既修饰指针又修饰常量时，指针指向和指针指向的值都不可以更改\n");
    return 0;
}

五、指针运算

5.1 指针± 整数

因为数组在内存中是连续存放的，只要知道第⼀个元素的地址，顺藤摸⽠就能找到后⾯的所有元素。

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//指针+- 整数
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int* p = &arr[0];
  int i = 0;
  int sz = sizeof(arr) / sizeof(arr[0]);
  for (i = 0; i < sz; i++)
  {
    printf("%d ", *(p + i));//p+i 这⾥就是指针+整数
  }
  return 0;
}

5.2 指针-指针

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int my_strlen(char* s)
{
  char* p = s;
  while (*p != '\0')
    p++;
  return p - s;
}
int main()
{
  printf("%d\n", my_strlen("abc"));
  return 0;
}

5.3 指针的关系运算

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int* p = &arr[0];
  int i = 0;
  int sz = sizeof(arr) / sizeof(arr[0]);
  while (p < arr + sz) //指针的⼤⼩⽐较
  {
    printf("%d ", *p);
    p++;
  }
  return 0;
}

六、野指针

概述

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

野指针即野狗，野狗即野指针，如果我们放任不管，后果不堪设想，存在危险。

6.1 野指针成因

1、指针没有初始化

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
  int* p;//局部变量指针未初始化，默认为随机值
  *p = 20;
  return 0;
}

2指针越界访问

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
  int arr[10] = { 0 };
  int* p = &arr[0];
  int i = 0;
  for (i = 0; i <= 11; i++)
  {
    //当指针指向的范围超出数组arr的范围时，p就是野指针
    *(p++) = i;
  }
  return 0;
}

3、指针指向的空间释放

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int* test()
{
  int n = 100;
  return &n;
}
int main()
{
  int* p = test();
  printf("%d\n", *p);
  return 0;
}

6.2 如何规避野指针

针对上面的成因，我们就能去避免出现野指针

1、指针初始化

如果明确知道指针指向哪⾥就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL.

NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址

会报错。

#ifdef __cplusplus
      #define NULL 0
   #else
      #define NULL ((void *)0)
   #endif

#include <stdio.h>
int main()
{
  int num = 10;
  int* p1 = &num;
  int* p2 = NULL;
  return 0;
}

2、避免越界

就是不超过范围，自己把握

3、指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性

当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，后期不再使⽤这个指针访问空间的

时候，我们可以把该指针置为NULL。因为约定俗成的⼀个规则就是：只要是NULL指针就不去访问，

同时使⽤指针之前可以判断指针是否为NULL。

就是把野狗给拴起。拴起来后，也不能接近它，要绕着走，不能条狗，可远观，不可亵玩焉。

对有指针，我们要先判断是否为NULL，不是的话，才可以去使用

int main()
{
 int arr[10] = {1,2,3,4,5,67,7,8,9,10};
 int *p = &arr[0];
 for(i=0; i<10; i++)
 {
 *(p++) = i;
 }
 //此时p已经越界了，可以把p置为NULL
 p = NULL;
 //下次使⽤的时候，判断p不为NULL的时候再使⽤
 //...
 p = &arr[0];//重新让p获得地址
 if(p != NULL) //判断
 {
 //...
 }
 return 0;
}

4、避免返回局部变量的地址

七、assert断言

使用

#define NDEBUG
#include <assert.h>

assert() 宏接受⼀个表达式作为参数。如果该表达式为真（返回值⾮零）， assert() 不会产⽣

任何作⽤，程序继续运⾏。如果该表达式为假（返回值为零）， assert() 就会报错，在标准错误

流 stderr 中写⼊⼀条错误信息，显⽰没有通过的表达式，以及包含这个表达式的⽂件名和⾏号。

⼀般我们可以在debug中使⽤，在release版本中选择禁⽤assert就⾏，在VS这样的集成开发环境中，

在release版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在release版本不

影响⽤⼾使⽤时程序的效率。

八、指针的使用和传址调用

8.1 传址调值

举个例子：写一个函数，交换两个整数

经过深思熟虑，你写出了下面的代码：

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void Swap1(int x, int y)
{
  int tmp = x;
  x = y;
  y = tmp;
}
int main()
{
  int a = 0;
  int b = 0;
  scanf("%d %d", &a, &b);
  printf("交换前：a=%d b=%d\n", a, b);
  Swap1(a, b);
  printf("交换后：a=%d b=%d\n", a, b);
  return 0;
}

运行后，发现并没有实现你想要的结果。并没有实现两个整数的交换

实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实

参。所以Swap是失败的了。

此时，我们传递地址：

# define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void Swap(int* px, int* py)
{
  int z = 0;
  z = *px;//z = a
  *px = *py;//a=b
  *py = z;//b = a
}
int main()
{
  int a = 10;
  int b = 20;
  printf("交换前:a=%d b=%d\n", a, b);
  //传址调用
  //
  Swap(&a, &b);
  printf("交换后:a=%d b=%d\n", a, b);
  return 0;
}

strlen模拟实现

# define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str) {
  size_t cnt = 0;
  assert(str!=NULL);
  while (*str!='\0') {
    cnt++;
    str++;
  }
  return cnt;
}
int main() {
  size_t len = my_strlen("abcdefg");
  printf("%zd\n", len);
  return 0;
}

C语言学习系列--＞看淡指针（1）