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）

一、概述

二、指针变量和地址

2.1 取地址操作符

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

2.2.1 指针变量

2.2.2 拆解指针类型

2.2.4 解引用操作符

2.3 指针变量的大小

三、指针变量的意义

3.1 指针的解引用

指针±整数

四、 const修饰指针

五、指针运算

5.1 指针± 整数

5.2 指针-指针

5.3 指针的关系运算

六、野指针

概述

6.1 野指针成因

6.2 如何规避野指针

七、assert断言

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

8.1 传址调值

strlen模拟实现

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

一、概述

二、指针变量和地址

2.1 取地址操作符

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

2.2.1 指针变量

2.2.2 拆解指针类型

2.2.4 解引用操作符

2.3 指针变量的大小

三、指针变量的意义

3.1 指针的解引用

指针±整数

四、 const修饰指针

五、指针运算

5.1 指针± 整数

5.2 指针-指针

5.3 指针的关系运算

六、野指针

概述

6.1 野指针成因

6.2 如何规避野指针

七、assert断言

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

8.1 传址调值

strlen模拟实现

热门文章

最新文章

相关课程

相关电子书

相关实验场景