万字深入理解C语言中的指针（1）

野生的编程萌新

已于 2024-04-21 07:42:46 修改

阅读量277

点赞数 6

分类专栏： C语言文章标签：开发语言 c语言

于 2023-09-25 13:54:48 首次发布

本文链接：https://blog.csdn.net/zjh20040819/article/details/133197757

版权

C语言专栏收录该内容

26 篇文章 0 订阅

订阅专栏

这里和大家分享一下C语言中的精髓——指针，总有的人会觉得好难啊，放心，慢慢来，没有学不会的知识，大家不要觉得他有多可怕，不要给自己心理压力，认真学肯定是会学会的。那么我们就开始今天的博客之旅了。

6.2.3 指针变量不使用时，及时放置NULL，指针使用之前一定要检查有效性

7. assert断言

8 传址调用

1.内存和地址

1.1 内存

再讲内存和地址之前，我们先举一个生活中的例子：假设你住在一栋2单元，20层的楼中，你的一个朋友想来找你玩，如果想要找到你。那他就要挨家挨户的寻找，这样的效率极低，但当我们根据单元和楼层房间信息的情况，给每一家一个门牌号，有了门牌号，你朋友得知了具体的门牌号们就可以迅速地找到你。在生活中每个房间都有房间号，有了房间号就可以提高效率，快速找到对应的房间。

那如果我们把上面的例子对照在计算机之中，会是怎么样的呢？

我们知道计算机上CPU（中央处理器）在处理数据的时候，需要的数据实在内存上读取的，处理后的数据也是会放在内存中，那我们买电脑的时候，电脑上内存是8GB/16GB/32GB等，那这些内存空间如何⾼效的管理呢？其实也是把内存划分为⼀个个的内存单元，每个内存单元的⼤⼩取1个字节。其实，每个内存单元，都相当于一个学生宿舍，一个字节空间里能放8个比特位，就好比一个八人寝，每个人都是一个比特位。每个内存单元也都有一个编号（就像是每个宿舍的门牌号），有了这个编号，CPU能够快速地找到一个内存空间。生活中我们把门牌号叫做地址，在计算机中我们把内存单元的编号也叫地址。C语言中给地址起了一个新名字：指针。所以我们可以这样理解：

内存单元的编号==地址==指针

1.2 理解编址

CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，⽽因为内存中字节很多，所以需要给内存进⾏编址(就如同宿舍很多，需要给宿舍编号⼀样)。计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。钢琴、吉他上⾯没有写音符的信息，但演奏者照样能够准确找到每⼀个琴弦的每⼀个位置，这是为何？因为制造商已经在乐器硬件层⾯上设计好了，并且所有的演奏者都知道。本质是⼀种约定出来的共识！硬件编址也是如此。⾸先，必须理解，计算机内是有很多的硬件单元，⽽硬件单元是要互相协同⼯作的。所谓的协同，⾄少相互之间要能够进⾏数据传递。但是硬件与硬件之间是互相独⽴的，那么如何通信呢？答案很简单，⽤"线"连起来。⽽CPU和内存之间也是有⼤量的数据交互的，所以，两者必须也⽤线连起来。我们可以简单理解，32位机器有32根地址总线。每根线只有两态，表⽰0,1【电脉冲有⽆】，那么⼀根线，就能表⽰2种含义，2根线就能表⽰4种含义，依次类推。32根地址线，就能表⽰2^32种含义，每⼀种含义都代表⼀个地址。地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传⼊ CPU内寄存器。

2 指针变量和地址

2.1 取地址操作符（&）

理清楚了内存和地址的关系，那么我们把关注点继续回到C语言上，在C语言上创建变量其在向内存申请空间。比如：

就像上面这个代码中我们创建了一个整型变量a，内存申请4个字节，用于存放整数10，他们对应的内存为0x0133FC6C。在获得a的地址时我们使用了一个操作符——取地址操作符（&），它可以帮助我们获得a的地址。虽然整型变量占⽤4个字节，我们只要知道了第⼀个字节地址，顺藤摸⽠访问到4个字节的数据也是可以的。

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

2.2.1 指针变量

那我们通过取地址操作符(&)拿到的地址是⼀个数值，⽐如：0x0133FC6C，这个数值有时候也是需要存储起来，⽅便后期再使⽤的，那我们把这样的地址值存放在哪⾥呢？答案是：指针变量中。比如：

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

指针变量也是一种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为地址。

2.2.2 如何拆解指针类型

我们看到上面p的类型是int*，那我们该如何理解指针的类型呢？

int a=10;
int* p=&a;

p左边写的是int*,*是在说明p是指针变量，而前面的int 是在说明p指向的是整型类型的对象。

2.2.3 解引用操作符

我们将地址保存起来，未来要是使用的话，那该怎么使用呢？在现实生活中，我们根据地址找到一个房间，在房间里可以拿走或者存放东西。在C语言中其实也是一样的，我们只要拿到地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，这里必须要提到一个操作符——解引用操作符（*）。

#include<stdio.h>
int main()
{
  int a=10;
  int* p=&a;
  *p=0;
  return=0;
}

上面的代码第6行就运用了解引用操作符，*p的意思就是就是通过p中存放的地址，找到指向的空间，*p其实就是a的变量了，所以*p=0；这个操作就是把a改成了0；这里大家肯定会想，既然你是把a的值改成0；那为什么不在赋值时直接给a赋值一个0，那不就完了，为什么还非要用指针呢？其实这里是把a的修改交给p来操作，这样我们对a的修改就多了一种途径，写代码也会相对灵活，后面会慢慢理解的。

2.3 指针变量的大小

前⾯的内容我们了解到，32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后是1或者0，那我们把32根地址线产⽣的2进制序列当做⼀个地址，那么⼀个地址就是32个bit位，需要4 个字节才能存储。如果指针变量是⽤来存放地址的，那么指针变的⼤⼩就得是4个字节的空间才可以。同理64位机器，假设有64根地址线，⼀个地址就是64个⼆进制位组成的⼆进制序列，存储起来就需要 8个字节的空间，指针变的⼤⼩就是8个字节。

#inlcude<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;
}

X86环境下运行结果

X64环境下运行结果

结论：

32位平台下地址是32个bit位，指针变量大小是4个字节。

64位平台下地址是64个bit位，指针变量大小是8个字节。

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

3. 指针变量类型的意义

指针变量的大小和类型⽆关，只要是指针变量，在同⼀个平台下，大小都是⼀样的，为什么还要有各种各样的指针类型呢？其实指针类型是有特殊意义的。

3.1 指针的解引用

观察对比下面两段代码，主要是在调试的时候内存的变化。

//代码1
#include<stido.h>
int main()
{
  int a=0x11223344;
  int * p1=&a;
  *p1=0;
  return 0;
}

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

通过上面代码的调试可以看到，代码1会将4个字节全部改为0，而代码2只会将第一个字节改为0。这里我们可以得到一个结论：指针的类型决定了对指针解引用时有多大的权限（一次能操作几个字节）。比如：上面的代码中char*解引用就只访问了一个字节，而int*解引用可以访问4个字节。

3.2 指针+整数

先观察下面的代码，再调试观察它地址的变化：

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

通过上面的代码及其运行结果我们可以知道，char*类型的指针变量+1可以跳过1个字节，int*类型的指针变量+1可以跳过4个字节，这是指针变量类型的差异带来的变化。指针的类型决定了指针向前或者向后走一步的距离。

4. const修饰指针

4.1 const修饰变量

变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量我们也可以修改这个变量。但是如果我们希望一个变量加上限制，不能被修改，我们该怎么做呢？这时候我们就要使用const了

#include<stdio.h>
int main()
{
  int a=0;
  a=10;//a是可以修改赋值的
  const int b=0;
  b=10;//b是无法修改赋值的
  return 0;
}

通过上述代码的报错结果我们可以知道，b是不能修改的，b的本质是一个变量，只不过经过const的修饰后，在语法上面加了限制，主要我们对b的值进行修改，就不符合语法规则，就开始报错，致使我们无法修改b的值。但是如果我们绕过b，使用b的地址，去修改b的值就能够做到了，虽然这样是在打破语法规则。

#include<stdio.h>
int main()
{
  const int b=0;
  printf("b=%d\n",b);
  int * p=&b;
  *p=10;
  printf("b=%d\n",b);
  return 0;
}

我们通过调试结果可以发现b的值确实被修改了，但是我们还是要思考一下，为什么b要被const修饰？目的不就是为了b的值不被修改吗，但是当拿到b的地址就能修改b的值了，这样就算打破了const的限制了，这样不符合语法规则，所以我们应该让即使拿到b的地址也无法修改b的值，那我们该怎么做i呢？

4.2 const修饰指针变量

#include<stdio.h>
void test1()
{
  int a=0;
  int b=1;
  int * p=&a;
  *p=10;//查看指针指向的内容能否通过指针来进行修改
  p=&b;//查看指针变量本身能否被修改  下面的test2、test3、test4中同理
}
void test2()
{
  int a=0;
  int b=1;
  const int * p=&a;
  *p=10;
  p=&b;
}
void test3()
{
  int a=0;
  int b=1;
  int * const p=&a;
  *p=10;
  p=&b;
}
voi test4()
{
  int a=0;
  int b=1;
  const int * const p=&a;
  *p=10;
  p=&b;
}
int main()
{
  test1();//测试无const修饰的情况
  test2();//测试const放在*左边的情况
  test3();//测试const放在*右边的情况
  test4();//测试const放在*左右两边的情况
  return 0;
}

根据上面的代码及其报错原因，我们可以得到一个结论：

const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本⾝的内容可变。

const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。

5. 指针运算

指针的基本运算有3种：

指针+整数

指针-指针

指针的关系运算

5.1 指针+整数

因为在数组中内存是连续存放的，只要知道第一个元素的地址，就可以顺藤摸瓜找到后面的所有元素。

#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));
   }
  return 0;
}

5.2 指针-指针

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

5.3 指针的关系运算

#icnlude<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. 野指针

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

6.1 野指针形成的原因

6.1.1 指针未初始化

#include<stdio.h>
int main()
{
  int *p;//指针未初始化，默认随机值
  *p=10;
  return 0;
}

6.1.2 指针越界访问

#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;
  for(i=0;i<11;i++)//当指针指向的范围超出arr数组的范围时，指针就是野指针
   {
     *(p++)=i;
   }
  return 0;
}

6.1.3 指针指向的空间释放

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

6.2 如何避免野指针

6.2.1 指针初始化

如果明确知道指针指向哪⾥就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL， NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址会报错。初始化如下：

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

6.2.2 小心指针越界

⼀个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。所以我们再创建指针变量的时候一定要注意：千万不要越界。

6.2.3 指针变量不使用时，及时放置NULL，指针使用之前一定要检查有效性

当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，后期不再使⽤这个指针访问空间的时候，我们可以把该指针置为NULL。因为约定俗成的⼀个规则就是：只要是NULL指针就不去访问，同时使⽤指针之前可以判断指针是否为NULL。在这里我们打一个比喻，我们可以把野指针想象成一只狼，狼如果放任不管的话是非常危险的，所以我们要找笼子把他关起来，这样就相对安全了，给指针变量及时赋值NULL，就好比把狼关起来，就是把野指针暂时管理起来。不过就算我们用笼子把狼关起来，我们也要绕开走，千万不能隔着笼子挑逗它，这是非常危险的，对于指针而言也是这样的，在使用前我们要先判断它是否为NULL，如果是的话那我们不能直接使用，如果不是的话我们可以直接使用。

#include<stdio.h>
int main()
{
  int arr[10]={1,2,3,4,5,6,7,8,9,10};
  int * p=&arr[0];
  for(i=0;i<10;i++)
   {
     *(p++)=i;
   }
  p=NULL;//此时的p已经越界了，可以给它置为NULL
  //下次使用的时候，先判断p是不是为NULL，如果不是那就接着写
  if(p!=NULL)
   {
     //这里写入语句
   }
  return 0;
}

7. assert断言

assert.h头文件定义了宏assert（），用于在程序运行时确保程序符合指定的条件，如果不符合就报错终止，这个宏常常被称为断言。

assert(p!=NULL);

上面这一行代码表示：当程序运行至这一行语句时，验证变量p是否等于NULL，如果不等于，程序继续往下运行，如果等于，程序报错终止并且给出报错信息提示。assert（）宏接受一个表达式作为参数。如果该表达式为真（非零返回值），assert（）不会产生任何影响，程序继续运行，相反的如果表达式为假（返回值为0），assert（）就会报错，标准流stderr中输入一条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行数。assert（）的使用对程序员还是很友好的，使用assert（）的几个好处：它不仅能自动标示出文件和出错的行数，还有一种无需修改代码就能开启或者关闭assert（）的机制，如果在确定程序已经没有问题，不需要做出断言时，就在#include<assert.h>前面，定义一个宏NDEBUG。

#define NDEBUG
#include<assert.h>

然后重新编译程序，编译器就会禁用文件中的所有assert()语句，如果程序又出现错误，可以移除这条#define NEDBUG语句或者注释掉，再次编译，这样就重新启用了assert（）语句，assert() 的缺点是，因为引⼊了额外的检查，增加了程序的运⾏时间。如果你和我一样都是使用的VS编译器，那么我们可以在debug中使用，在release版本中选择禁⽤assert就⾏，在VS这样的集成开发环境中，在release版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在release版本不影响用户使⽤时程序的效率。

8 传址调用

学习指针的目的是用指针解决问题，那么什么样的问题，非用指针不可呢？

例如：写一个函数，先输入两个整型变量，再交换这两个整型变量的值。

思考一段时间后容易写出这样的代码：

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

我们调试一下结果为：

我们观察调试的结果发现，a和b的值未进行交换，这是为什么呢？我们逐语句调试一下看看：

我们发现在main函数内部，创建了a和b，a的地址是0x006ffbfc，b的地址是0x006ffbf0，在调⽤ Swap函数时，将a和b传递给了swap函数，在swap函数内部创建了形参x和y接收a和b的值，但是 x的地址是0x006ffb18，y的地址是0x006ffb1c，x和y确实接收到了a和b的值，不过x的地址和a的地址不⼀样，y的地址和b的地址不⼀样，相当于x和y是独⽴的空间，那么在swap函数内部交换x和y的值，自然不会影响a和b，当Swap函数调⽤结束后回到main函数，a和b的没法交换。swap函数在使⽤的时候，是把变量本⾝直接传递给了函数，这种调⽤函数的⽅式我们之前在函数的时候就知道了，这种叫传值调用。从这里我们可以得到一个结论：实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实参。所以swap是失败的了。

那么我们该怎么办呢？我们现在要解决的就是当调⽤swap函数的时候，swap函数内部操作的就是main函数中的a和b，直接将a和b的值交换了。那么就可以使⽤指针了，在main函数中将a和b的地址传递给Swap函数,swap函数⾥边通过地址间接的操作main函数中的a和b就好了。

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

我们调试运行一下看看结果：