C生万物 | 从浅入深理解指针【第一部分】(二)

简介: C生万物 | 从浅入深理解指针【第一部分】(二)

C生万物 | 从浅入深理解指针【第一部分】(一):https://developer.aliyun.com/article/1426612

五、const修饰指针

  • 变量是可以修改的,如果把变量的地址交给一个指针变量,通过指针变量的也可以修改这个变量。
#include<stdio.h>
int main() {
  int n = 100;
  n = 200;
  printf("%d\n", n);
  return 0;
}

但是如果我们希望一个变量加上一些限制,不能被修改,怎么做呢?这就是const的作用。

int main() {
  const int n = 100;
  n = 200;//err
  printf("%d\n", n);
  return 0;
}

bbe7eff81f403f879de3bcf7a16db273_9aae2e2234504a6c8e186beea96d24d6.png


  • 上述代码中n是不能被修改的,其实n本质是变量,只不过被const修饰后,在语法上加了限制,只要我们在代码中对n就行修改,就不符合语法规则,就报错,致使没法直接修改n。
  • 但是如果我们绕过n,使用n的地址,去修改n就能做到了,虽然这样做是在打破语法规则。
  • 那有人这样想,这样不能修改,那我绕个弯,把n的地址取出来,交给一个指针变量p,然后进行修改intmain(){constint n =100;int* p =&n;*p =200;printf("%d\n", n);return0;}


  • 哎!它怎么修改了?就比如说有个门,门锁上了,看见有个窗户,我从窗户进去了,这个行为就是钻窗户行为~~
  • 这里一个确实修改了,但是我们还是要思考一下,为什么n要被const修饰呢?就是为了不能被修改,如果p拿到n的地址就能修改n,这样就打破了const的限制,这是不合理的,所以应该让p拿到n的地址也不能修改n,那接下来怎么做呢

5.1 const修饰指针变量

const修饰指针有两种情况:

  1. const放在*的左边
  2. const放在*的右边
  • 首先我们先将const放在*的左边~~

int main() {
  int m = 100;
  int n = 10;
  const int* p = &n;
  *p = 0;
  p = &m;
  printf("%d\n", n);
  return 0;
}
  • 这里可以看到p指向的值不能被修改
  • p变量还是可以被修改的~~
  • 然后我们先将const放在*的左边~~
int main() {
  int m = 100;
  int n = 10;
  int* const p = &n;
  *p = 0;
  p = &m;
  printf("%d\n", n);
  return 0;
}

  • 可以看到p指向的对象可以被修改~~

结论:

  1. const如果放在*的左边,修饰的是指针指向的内容,保证指针指向的内容不能通过指针来改变。但是指针变量本身的内容可变。
  2. const如果放在*的右边,修饰的是指针变量本身,保证了指针变量的内容不能修改,但是指针指向的内容,可以通过指针改变。
  • 那有的同学说我这样放,可不可以?可以!!!
int const *  p = &n;
int *const  p = &n;
  • 这两种方法都是可以的,我们只是关注的是const放在*左边还是右边

六、指针运算

6.1 指针± 整数

  • 因为数组在内存中是连续存放的,只要知道第一个元素的地址,顺藤摸瓜就能找到后面的所有元素。
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

#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;
}
  • 接下来我们就调试起来看一看

  • 可以看到已经放进去了


  • 这里p+i就访问到每一个元素了~~

6.2 指针-指针

  • 指针-指针是有前提的,指针和指针两个指针的指向同一块空间
  • 我们先来看下面的这个一个代码,输出的结果是多少?
int main() {
  int arr[10] = { 0 };
  int ret = &arr[9] - &arr[0];
  printf("%d", ret);
  return 0;
 }
  • 答案是9~~,我们来分析一下:

  • 也可以这样理解,&arr[0]+9—>>>&arr[9]
  • 结论: 指针-指针得到的绝对值,是指针和指针之间元素的个数
  • 那有的同学说,那这个有什么用呢?
  • 还记得有一个函数strlen吗?
  • strlen的功能是求字符串长度,如果有同学不了解这个函数的话可以去cplusplus网站上看一下
  • 我们来看一下怎么使用int main()
int main() 
{
  char arr[] = "abcdef";
  int len = strlen(arr);
  printf("%d\n", len);
  return 0;
}


  • 可以看到它已经求出字符串长度了~~
  • 我们知道字符串的结束标志是\0,让我求长度,我就统计\0之前出现字符的个数
  • 那我们现在自己模拟实现一下这个函数~~
  • 我们这里写成my_strlen,我们把数组传参,然后形参以指针接收,指针指向了数组首元素的地址,然后我们定义个计数器count,如果p!=\0,count++p++,最后返回count的个数~~
int my_strlen(char* p)
{
  int count = 0;
  while (*p != '\0')
  {
    count++;
    p++;
  }
  return count;
}
int main() 
{
  char arr[] = "abcdef";
  int len = my_strlen(arr);
  printf("%d\n", len);
  return 0;
}
  • 可以看到也统计出来个数了~~

  • 我们再写出另一个版本,接下来继续看~~
  • 我们知道指针减去指针得到的是元素之间的个数
  • 首先我记录一下起始位置,让p++,一直找到\0为止,最后返回p-s就得到了元素的个数~~
  • 我们来看一下代码和结果~~
#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;
}

明白了上面的内容,我们再来将一个指针的关系运算~~

6.3 指针的关系运算

  • 所谓的关系运算,就是比较大小
  • 我们来看一下例子~~
#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;
}
  • 这里我们比较的是两个地址的大小关系~~
  • 我们可以看到,也是可以打印出来的~~


七、野指针

  • 概念: 野指针就是指针指向的位置是不可知的(随机的、不正确的、没有明确限制的)

7.1 野指针成因

指针未初始化:

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

  • 可以看到这里报了错,如果你有看过我写的函数的栈帧创建与销毁就明白了,局部变量不初始化默认里面放的是cccccccc
  • 所以一个局部变量不初始化的话,会得到一个随机值~~
  • 而随便的一个地址,能解引用吗?不能!!!
  • 一块空间你要想使用,你需要先申请拿到这块空间

指针越界访问:

  • 我们先来看代码

7.1 野指针成因

#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;
}
  • 我们这里的p++是先执行的,而p++是先使用后++
  • 我们这里可以看到,我把arr[0]的地址放入了*p指针变量,然后我们进行遍历赋值,那我们这里判断条件是不是就越界访问了,超出了数组的范围,当指针指向的范围超出数组arr的范围时,p就是野指针,这是很危险的~~
  • 我们这里还可以调试一下看看~~

  • 可以看到,数组arr造到了破坏,而越界访问的内容也修改了,如此可见,这多么的危险!!!


7.2 指针指向的空间释放

  • 我们先来看一下下面的代码~~
#include <stdio.h>
int* test()
{
  int n = 100;
  return &n;
}
int main()
{
  int* p = test();
  printf("%d\n", *p);
  return 0;
}
  • 这里创建了一个函数test(),返回一个地址,既然这个函数返回的是一个地址,那我用一个指针来接收,然后*p这个地址
  • 这个n在出这个函数的时候被销毁了,这就会造成指针指向的空间释放~~


八、如何规避野指针

8.1 指针初始化

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

什么意思呢,我们用代码来说~~

  • 这里的p非常明确的指向了a,直接赋值~~
int main() 
{
  int a = 10;
  int* p = &a;
  return 0;
}
  • 我们这里假设在这里创建了个ptr,我现在不用,但我可以在后面才会用,但是这个指针变量不能空着,这个时候我们要给他初始化NULL
int main() 
{
  int a = 10;
  int* p = &a;
  int* ptr = NULL;
  return 0;
}
  • NULL是什么呢?本质上就是空指针,我们这个时候可以右键,转到定义里看一下

  • 那有的同学会说,那我直接给他赋值为0,可不可以呢?本质上是可以的,但是,当我们赋值为0了,有的时候会以为是一个整数,而我们赋值为NULL的时候,那就很明显了,一看就是空~~
  • NULL 是C语言中定义的一个标识符常量,值是0,0也是地址,这个地址是无法使用的,读写该地址会报错。
  • 这里我们也可以看到~~

2ad39d330f1ecb18dc39530c0301e4ae_6ede515bbbd746f4b0d3f9d5d5719688.png

8.2 小心指针越界

  • 一个程序向内存申请了哪些空间,通过指针也就只能访问哪些空间,不能超出范围访问,超出了就是越界访问
  • 这个谁都帮不了你,只能自己小心,不要越界~~
  • 一个程序员想写bug,谁都拦不住~~n在出这个函数的时候被销毁了,这就会造成指针指向的空间释放~~

8.3 指针变量不再使用时,及时置NULL,指针使用之前检查有效性

  • 当指针变量指向一块区域的时候,我们可以通过指针访问该区域,后期不再使用这个指针访问空间的时候,我们可以把该指针置为NULL。因为约定俗成的一个规则就是:只要是NULL指针就不去访问,同时使用指针之前可以判断指针是否为NULL。
  • 我们可以把野指针想象成野狗,野狗放任不管是非常危险的,所以我们可以找一棵树把野狗拴起来,就相对安全了,给指针变量及时赋值为NULL,其实就类似把野狗栓前来,就是把野指针暂时管理起来。
  • 不过野狗即使拴起来我们也要绕着走,不能去挑逗野狗,有点危险;对于指针也是,在使用之前,我们也要判断是否为NULL,看看是不是被拴起来起来的野狗,如果是不能直接使用,如果不是我们再去使用。
  • 下面我们来看一段代码~~
  • 这里我们创建了一个数组,然后用指针遍历这个数组,当遍历完后,指针已经指向了10的后面,指向了不属于我们的空间
  • 假设暂时不再使用p了,为了安全,我们可以把p赋值为NULL
  • 如果后面还会用到这个指针,我们再把这个p赋值,我们还可以再进行判断是否为NULL
int main()
{
  int arr[10] = { 1,2,3,4,5,67,7,8,9,10 };
  int* p = &arr[0];
  for (int i = 0; i < 10; i++)
  {
    *(p++) = i;
  }
  //此时p已经越界了,可以把p置为NULL
  p = NULL;
  //下次使用的时候,判断p不为NULL的时候再使用
  //...
  p = &arr[0];//重新让p获得地址
  if (p != NULL) //判断
  {
    //...
  }
  return 0;
}

8.4 避免返回局部变量的地址

  • 我们来看下面这一段代码
  • 首先我们先调用了一下test函数,函数里创建了个数组,数组是局部变量,而我们返回了这个数组的地址,我们使用了一个指针变量p来接收,当test函数返回的时候局部变量已经被操作系统回收了,这就会造成野指针,如果有看过函数的栈帧的创建与销毁的话就明白了
  • 返回栈空间地址的问题,很容易造成野指针的问题~~
int* test()
{
  //局部变量
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  //.....
  return arr;
}
int main()
{
  int* p = test();//p就是野指针
  return 0;
}

九、assert断言

  • assert.h 头文件定义了宏assert() ,用于在运行时确保程序符合指定条件,如果不符合,就报错终止运行。这个宏常常被称为“断言”。
assert(p != NULL);
  • 上面代码在程序运行到这一行语句时,验证变量p是否等于NULL 。如果确实不等于NULL ,程序继续运行,否则就会终止运行,并且给出报错信息提示。
  • 我们可以看到,什么都不会发生~~
#include <assert.h>
int main()
{
  int a = 10;
  int* p = &a;
  assert(p != NULL);
  return 0;
}

5d5370f510d0ea01f2795e3f324718bd_deae335e0c624599b8d46f1a6087acf3.png

  • 当我们赋值为了一个空指针时,可以看到会报错误
  • 通过这样一个方式就可以拦住他~~
#include <assert.h>
int main()
{
  int a = 10;
  int* p = NULL;
  assert(p != NULL);
  return 0;
}

9889672608d86df71e824e45185f2fe7_13d61fdd8141406aa457af6bf2ce216b.png

  • assert() 宏接受一个表达式作为参数。如果该表达式为真(返回值非零), assert()不会产生任何作用,程序继续运行。如果该表达式为假(返回值为零), assert() 就会报错,在标准错误流stderr 中写入一条错误信息,显示没有通过的表达式,以及包含这个表达式的文件名和行号。
  • assert() 的使用对程序员是非常友好的,使用assert() 有几个好处:它不仅能自动标识文件和出问题的行号,还有一种无需更改代码就能开启或关闭assert() 的机制。如果已经确认程序没有问题,不需要再做断言,就在#include  语句的前面,定义一个宏NDEBUG 。
#define NDEBUG
#include <assert.h>
  • 然后,重新编译程序,编译器就会禁用文件中所有的assert() 语句。如果程序又出现问题,可以移除这条#define NDBUG 指令(或者把它注释掉),再次编译,这样就重新启用了assert() 语句。
  • assert() 的缺点是,因为引入了额外的检查,增加了程序的运行时间。
  • 一般我们可以在debug中使用,在release版本中选择禁用assert就行,在VS这样的集成开发环境中,在release版本中,直接就是优化掉了。这样在debug版本写有利于程序员排查问题,在release版本不影响用户使用时程序的效率。

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

一直叫传值调用,一种叫传址调用,接下来我们继续看~~

10.1 传址调用

  • 学习指针的目的是使用指针解决问题,那什么问题,非指针不可呢?
    例如:写一个函数,交换两个整型变量的值
  • 一番思考后,我们可能写出这样的代码:
#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;
}

当我们运行代码,结果如下:

646a9187e15532f881d56788de1e3fff_6051bc5fdce84fbea6a7fb428a7c08be.png

  • 这里怎么没有达到交换的效果?我们来调试看一下
  • 我们可以看到只有x和y交换了,而a和b没有交换

760d59680cba360cae8db3705cd3dcf9_196421147f1b444797ea84c2a49e9596.png

  • 我们发现在main函数内部,创建了a和b,a的地址是0x0039f9f0,b的地址是0x0039f9e4,在调用Swap1函数时,将a和b传递给了Swap1函数,在Swap1函数内部创建了形参x和y接收a和b的值,但是x的地址是0x0039f90c,y的地址是0x0039f910,x和y确实接收到了a和b的值,不过x的地址和a的地址不一样,y的地址和b的地址不一样,相当于x和y是独立的空间,那么在Swap1函数内部交换x和y的值,自然不会影响a和b,当Swap1函数调用结束后回到main函数,a和b的没法交换。Swap1函数在使用的时候,是把变量本身直接传递给了函数,这种调用函数的方式我们之前在函数的时候就知道了,这种叫传值调用。

结论: 实参传递给形参的时候,形参会单独创建一份临时空间来接收实参,对形参的修改不影响实参。所以Swap是失败的了。

10.2 传址调用

  • 那怎么办呢?
  • 我们现在要解决的就是当调用Swap函数的时候,Swap函数内部操作的就是main函数中的a和b,直接将a和b的值交换了。那么就可以使用指针了,在main函数中将a和b的地址传递给Swap函数,Swap函数里边通过地址间接的操作main函数中的a和b就好了。
#include <stdio.h>
void Swap2(int* px, int* py)
{
  int tmp = 0;
  tmp = *px;
  *px = *py;
  *py = tmp;
}
int main()
{
  int a = 0;
  int b = 0;
  scanf("%d %d", &a, &b);
  printf("交换前:a=%d b=%d\n", a, b);
  Swap2(&a, &b);
  printf("交换后:a=%d b=%d\n", a, b);
  return 0;
}

首先看输出结果:

b06572311894c3705c62d422a013fd84_655110fa56f1421f8467111f083bc2b0.png

  • 我们可以看到实现成Swap2的方式,顺利完成了任务,这里调用Swap2函数的时候是将变量的地址传递给了函数,这种函数调用方式叫:传址调用


十一、strlen的模拟实现

  • 这个我们上面已经实现过了,这次我们再写的全一些~~
  • 我们创建了一个字符数组,要求出这个字符串的长度,我们写一个my_strlen()
  • 它传参传的是数组首元素的地址,我们用一个*str的指针来接收,我们这个函数期望这个字符串来修改吗?不期望,这里我们再加上一个const
  • 这里我们需要断言str,确保指针的有效性
  • 现在str指向a的,当str!='\0'str++,计数器也++,最后返回计数器~~
  • 求字符串的时候没有负数吧,我们就可以设置成size_t
  • 现在软件更加健壮了,也叫鲁棒性~~

计数器方式

size_t my_strlen(const char* str)
{
  size_t count = 0;
  assert(str);
  while (*str)
  {
    count++;
    str++;
  }
  return count;
}
int main()
{
  char arr[] = "abcdef";
  size_t len = my_strlen(arr);
  printf("%zd\n", len);
  return 0;
}


相关文章
C生万物 | 从浅入深理解指针【最后部分】(二)
C生万物 | 从浅入深理解指针【最后部分】(二)
|
3月前
|
存储 C++
C生万物 | 从浅入深理解指针【第三部分】(转移表的实现)
C生万物 | 从浅入深理解指针【第三部分】(转移表的实现)
C生万物 | 从浅入深理解指针【第二部分】(二)
C生万物 | 从浅入深理解指针【第二部分】(二)
|
3月前
|
编译器
C生万物 | 从浅入深理解指针【第二部分】(一)
C生万物 | 从浅入深理解指针【第二部分】 前言: 如果没有看过第一部分的话,推荐先看第一部分,然后再来看第二部分~~
|
3月前
|
C语言 C++
C生万物 | 从浅入深理解指针【最后部分】(一)
C生万物 | 从浅入深理解指针【最后部分】(一)
C生万物 | 从浅入深理解指针【第四部分】(qsort的使用和模拟实现)
C生万物 | 从浅入深理解指针【第四部分】(qsort的使用和模拟实现)
|
2天前
|
存储 C语言
C语言 — 指针进阶篇(下)
C语言 — 指针进阶篇(下)
3 0
|
2天前
|
存储 C语言 C++
C语言 — 指针进阶篇(上)
C语言 — 指针进阶篇(上)
5 0
|
17天前
|
存储 人工智能 编译器
C语言指针详解
指针运算,指针和数组,二级指针
C语言指针详解
|
17天前
|
存储 C语言
C语言第二十四弹---指针(八)
C语言第二十四弹---指针(八)