1. 前言🚩

我们在介绍C语言时已经给大家介绍过指针的概念以及内存地址的概念了,这里我们就不再重复说明前面的内容,对指针毫无了解的朋友可以先跳转介绍C语言阅读完第六节再来学习!

2. 指针类型🚩

首先我们要知道:

指针变量在32位平台下是4个字节

指针变量在64位平台下是8个字节

C语言中的变量类型有整型,浮点型,字符型等等,其实指针也有自己的类型比如:

char  *pc = NULL;
int   *pi = NULL;
short *ps = NULL;
long  *pl = NULL;
float *pf = NULL;
double *pd = NULL;
1

char 类型的指针是为了存放 char 类型变量的地址。*

short 类型的指针是为了存放 short 类型变量的地址。*

int 类型的指针是为了存放 int 类型变量的地址。*

我们可以这样理解:

3. 指针变量的意义🚩

3.1 指针解引用🏁

我们在编译器中写上这样一段代码:

#include <stdio.h>
int main()
{
  int a = 0x11223344;//0x是16进制的数
  int* pa = &a;
  char* pc = &a;
  *pa = 0;
  *pc = 0;
  return 0;
}

我们可以在调试的内存窗口看见a的值已经被放在内存中了

然后我们运行起来:

指针解引用

我们可以发现, int 类型的指针解引用可以改变4个字节的内容,而 char 类型的指针解引用只能改变1个字节的内容**

所以这里我们得到一个结论:指针的类型可以决定指针解引用时能访问多少个字节的内容

3.2 指针 ± 整数🏁

这里我们先写上这样一段代码:

#include <stdio.h>
//演示实例
int main()
{
 int n = 10;
 char *pc = (char*)&n;//强制类型转换
 int *pi = &n;
 printf("%p\n", &n);//%p是打印地址的意思
 printf("%p\n", pc);
 printf("%p\n", pc+1);
 printf("%p\n", pi);
 printf("%p\n", pi+1);
 return  0;
}

我们在编译器上运行会打印这样的内容:(不同编译器不同电脑出现地址会有差异)

这里因为它们前面的地址都相同,所以我们只看FA后面的内容.我们首先要理解:打印的第一个是n的地址,而pi和pc中就是存储的n的地址,所以打印出来的第一个,第二个,第四个的地址是相同的,都是FA84

下面我们会发现:

pc是字符型指针,pc加一后打印FA85.相比于84加了一个1,也就是加了一个字符型的空间

pi是整型指针,pi加一后打印FA88.相比于84加了一个4,也就是加了一个整型的空间

这里我们把加一改为加二,加三得到的结果就是往后走字符型*步数或整型×步数.

这里我们就得到一个结论:指针的类型决定了指针向前或者向后走一步有多大（距离）

4. 野指针🚩

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

形成野指针可能有下面这几种原因:

指针未初始化

指针越界访问

指针指向的空间被释放了

我们一一来讨论,并且给出解决办法

4.1 指针未初始化导致野指针🏁

我们先看下面这段错误的代码:

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

这里我们定义指针变量p时,并没有为它初始化一个地址,所以这里的指针p是指向了内存中随机一个地址,然后你再将这个随机地址的内容赋值给20,这是非常危险的行为!你并不知道你将计算器哪个地址的值修改了,这种行为的结果是无法预测的

4.2 指针越界访问🏁

我们先来看下面这段错误的代码:

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

我们知道10个元素的数组的小标范围是0~9,这里当i等于10时,就已经越界了.数组以外的内容实际上也就是随机的,内存中随机位置的值改变了这也是非常危险的行为!就好比你去餐厅吃饭,吃完了你的菜你还想吃隔壁桌的菜!

4.3 指针指向的空间被释放了🏁

先来看这段错误的代码:

#include <stdio.h>
int* test()
{
  int n = 10;
  return &n;
}
int main()
{
  int* p = test();
  //这里再使用p
  return  0;
}

这里我们的test函数会返回n变量的地址给指针p.但是我们知道,函数调用完后,为函数创建的内存就还给操作系统了,但是外面还有指针拿到了已经还给操作系统的地址,再使用这个指针变量或者改变它,就会出现问题,这种行为也是非常危险的!就好比于张三今天去酒店住了一晚,第二天张三退房离开酒店后给他的好友李四打电话告诉李四酒店的房间号,让李四接着去住,这里的张三就好比变量n,而李四就是指针变量p!

4.4. 如何避免出现野指针问题🏁

指针初始化

小心指针越界

指针指向空间释放，及时置NULL

避免返回局部变量的地址

指针使用之前检查有效性

像我们的一个野指针问题可以这样修改:

#include <stdio.h>
int main()
{
    int *p = NULL;//暂时不知道给指针赋什么值时先给空指针NULL
    //....
    int a = 10;
    p = &a;
    if(p != NULL)
   {
        *p = 20;
   }
    return 0;
}

这里的NULL是空指针,这里的操作就是在告诉编译器我们现在定义的指针变量暂时什么位置都不指向,当我们的目标内容a出现后,再将指针变量指向a的地址

5. 指针运算🚩

在将指针运算之前,我们要来理解这段代码:

int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int i = 0;
  int *p = arr;
  for (i = 0; i < 10; i++)
  {
  *(p+i)=i;
  arr[i]=i;//两个式子等价
  }

我们把指针变量p指向arr数组的地址,数组的地址实际上就是首元素的地址,而数组名arr恰好就是数组首元素的地址所以这里有一个等式:p其实就是arr,arr其实就等价于p,所以 *(p+i)实际上可以写为 *(arr+i)也可以写为p[i],也可以写为arr[i].这四种写法是等价的!

5.1 指针 ± 整数🏁

我们前面说,指针的类型决定了指针±整数时走了几个字节.这里我们就可以很直观的看见这样一个事实:

#define N 5
float values[N];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N];)
{
     *vp++ = 0;
}

我们在操作浮点型数组时,定义一个浮点型指针变量vp,vp++就是vp+1就刚好跳过一个浮点型的大小来到我们数组的下一个位置.假如我们定义的是字符型变量的话,那么指针变量+1不会跳过一个元素.这就是指针类型的实际运用.

5.2 指针 - 指针🏁

首先说结论:指针 - 指针得到的是两个指针之间的元素个数,比如:

#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int n = &arr[9] - &arr[0];
  int m= &arr[0] - &arr[9];
  printf("%d %d", n,m);
  return 0;
}
}

将数组下标为9的位置和下标为0的位置的指针相减,得到的就是数组0~9下标内有几个元素!打印出9,同理,如果是下标小的减去下标大的就会得到-9

指针 -指针 运算需要一个前提:那就是两个指针必须指向同一块空间(同一个数组)

6. 二级指针🚩

我们说每一个变量都在内存中对应一块自己对的地址,指针变量也不例外,虽然指针变量很特殊,它存放的值是其他变量的地址,但是指针变量本身也是地址.那么指针变量的地址存放在哪儿呢?那就是二级指针.

int a = 10;
  int* p = &a;//p是一级指针变量，指针变量也是变量，变量是在内存中开辟空间的，是变量就有地址
  int** pp = &p;//pp就是二级指针变量，二级指针变量就是用来存放一级指针变量的地址

我们可以这样理解:

6.1 二级指针的使用🏁

int a = 10;
    int b = 20;
  int* p = &a;//p是一级指针变量，指针变量也是变量，变量是在内存中开辟空间的，是变量就有地址
  int** pp = &p;//pp就是二级指针变量，二级指针变量就是用来存放一级指针变量的地址
  *pp = &b;//*pp就等价于p,相当于将p从指向a的地址改成了指向b
  **pp = 50;//*pp等价于p,而*p又等价于a,所以**pp就是将a的值从10改成了50

*pp就等价于p,相当于将p从指向a的地址改成了指向b

*pp等价于p,而 * p又等价于a,所以**pp就是将a的值从10改成了50

7. 指针数组🚩

指针数组是指针还是数组? 答案是数组,我们之前遇见过整型数组(存放整型元素的数组),字符型数组(存放字符型的数组),而指针数组顾名思义就是存放指针的数组. 我们来举个例子.:

#include<stdio.h>
int main()
{
  char arr1[] = "abcdef";
  char arr2[] = "hello world";
  char arr3[] = "cuihua";
  //指针数组
  char* parr[3] = { arr1, arr2, arr3 };
  int i = 0;
  for (i = 0; i < 3; i++)
  {
  printf("%s\n", parr[i]);
  }
  return 0;
}

我们可以这样理解这个数组:

数组中存放的是这个三个数组的数组名,也就是首元素地址,字符型的数组的首元素地址的类型就是char * 刚好能对上

parr[0]代表数组中第一个元素也就是数组arr1的首元素地址,%S可以打印出这一行字符串

parr[2][1] 首先定位到parr数组中的第三个元素:arr3,再分析arr3[1]就是arr3数组中第二个元素u,用%C可以打印出这个字符u

printf("%s",parr[0]);//打印arr1数组里的字符串
printf("%c",parr[2][1]);//打印arr3数组中的u字符
1

2

8. 总结🚩

指针一向被大家视为C语言中最难懂的部分,当然C语言能叱诧编程届多年不衰的一个重要原因就是有了指针这一利器!指针的初阶内容已经介绍完了,高阶指针将在未来的学习中更新!