【C生万物】指针的所有运用

最新推荐文章于 2025-12-17 18:30:38 发布

原创最新推荐文章于 2025-12-17 18:30:38 发布 · 109 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#c语言

C生万物专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了C语言中的指针概念，包括指针的类型、野指针的成因和规避方法、指针运算规则，以及指针与数组、二级指针、字符指针、指针数组和数组指针之间的关系。特别强调了指针在数组传参和函数指针使用中的重要性，并通过实例展示了回调函数的概念和应用。

1.指针是什么

指针的理解有两个要点

1.指针是内存中一个最小单元的编号，也就是地址

2.平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量（存放在指针中的值都会被当作地址处理）

指针变量：

我们可以通过&（取地址操作符）取出变量的内存及地址，把这些地址可以存放到一个变量中，这个变量就是指针变量。

#include<stdio.h>
int main()
{
int a = 10;//在内存中开辟一块空间
int *p=&a;//在这里我们使用&（取地址操作符）取出变量a的地址
          //a变量占用4个字节的空间，这是将a的4个字节的第一个字节的地址存放在变量p
return 0;
}

经过仔细的计算和权衡，我们发现一个字节给一个对应的地址是最合适的，那么如何编址呢？

对于32位的机器，有32根地址线，每根在寻址的时候产生高电压或者低电压也就是1或者0，那么就会有2的32次方个地址。

每个地址标识一个字节，那么我们就可以给(2^32Byte=2^32/1024KB=3^32/1024/1024MB=2^32/1024/1024/1024GB=4GB)4G的空间进行编址。

这里我们就明白：

在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。

那如果在64位机器上，那一个指针变量的大小是8个字节。

2.指针类型

我们都知道变量有不同的类型，那么指针也有不同的类型。

指针的定义方式就是：type+*

那么不同类型的指针就是为了存放该类型变量的地址。

下面俩个例子就是不同指针类型而产生的不同结果：

2.1指针+-整数

#include<stdio.h>
int main()
{
int a = 0;
int *pi = &a;
char *pc = (char*)&a;

print("%p\n",&a);
print("%p\n",pc);
print("%p\n",pc+1);
print("%p\n",pi);
print("%p\n",pi+1);
return 0;
}

程序的结果表示，pc和pa中都存的是a的地址，而pi+1和pc+1不同，pi+1是走了4个字节，而pc+1则只走了1个字节，这是因为指针类型不同，pi是int*（int的大小是4个字节），pc是char*（char的大小是1个字节）。

总结：指针的类型决定了指针向前或向后走一步的跨度是多少，即距离。

2.2指针的解引用

#include<stdio.h>

int main()
{
int a = 0x11111111;
int b = 0x11111111;
char *pc = (char*)&a;
int *pi = &b;

*pc = 0;
*pi = 0;

printf("%x\n",a);
printf("%x\n",b);
return 0;
}

在vs2022这个编译器中执行的结果是

11111100

0

（同时证明vs2022编译器是小端存储，大小端存储在以后的文章中会详细涉及）

总结：

指针的类型决定了，对指针解引用的时候有多大权限，即能操作几个字节。

比如：char*的指针解引用就只能访问一个字节，而int*的指针的解引用就只能访问四个字节

3.野指针

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

3.1野指针成因

1.指针未初始化

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

由于指针中存放的是随机值，所以指针指向的区域是不可知的，该指针就是野指针。

2.指针越界访问

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

我们不清楚arr数组后存放的是什么，如果指针越界访问到arr数组外的区域，该指针就是野指针。

3.指针指向的空间释放

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

int main()
{
int *p = test();
return 0;
}

test函数结束后，原来开辟的内存空间被释放，&a所指向的内存区域是未知的，该指针就是野指针。

3.2如何规避野指针

1.指针初始化。

2.小心指针越界。

3.指针指向空间释放，即使置NULL。

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

5.指针使用之前检查有效性。

if(*p != NULL)
{
*p = 10;
}

4.指针运算

4.1指针+-整数

在上面的文章中有讲到。

4.2指针-指针

同一类型的指针才能加减，因为如果不同类型的指针就无法确定指针的步长（距离），与指针+-整数同理。

4.3指针的关系运算（比较大小）

int arr[10] = 0;
int* p = NULL;
for(p = &arr[10];p > arr;)
{
*--p = 0;
}

若把代码简化，代码修改后如下：

for(p = arr[9];p >= arr;p--)
{
*p = 0;
}

虽然实际上绝大部分编译器上都可以顺利完成简化后的代码，然而我们还是应该避免这么写，因为标准并不保证它可行。

标准规定：

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

在上面的i这个例子中，用不太准确但是方便理解的方式来讲，意思就是标准允许数组的那个指针在比较的时候指向的是arr[10]，但是不允许指向的是arr[-1]（这种讲法很不恰当，我斟酌了很久要不要写在文章中，但是最后还是保留了，因为我觉得这个表达方式是大部分人可以接受的）。

5.指针和数组

在讲这一部分之前，我要补充一个关于数组的小知识：

数组名表示的是首元素的地址，而两种情况除外。

第一种情况：sizeof(数组名)的结果就是整个数组的大小。

第二种情况：&arr代表的是取出了整个数组的地址，它和首元素的地址的数值相同，但是&arr+1跳过的是整个数组的地址，arr+1跳过的是arr数组中第一个元素的地址，所以还是有很大差别。

有了这部分知识，我们就可以通过指针来访问数组

#include<stdio.h>
int main()
{
int arr[5] = {1, 2, 3, 4, 5};
int* p = arr;//将arr数组首元素的地址存在p中
int sz = sizeof(arr) / sizeof(arr[0]);
for(int i = 0; i < sz; i++)
{
printf("%d",*(p+i));//p+i就是数组下标为i的地址
}
return 0;
}

在上面程序中*(p+i)就相当于arr[i]，p+i就是arr[i]的地址。

6.二级指针

指针变量也是变量，而是变量就会有自己存放的位置即地址，那么指针变量的地址存放在哪里呢？

是的，就是二级指针。

int a = 0;
int *pa = &a;
int **ppa = &pa;

*ppa通过对ppa中的地址进行解引用，这样找到的就是pa 。

**ppa先通过*ppa找到pa，然后对pa进行解引用操作，那么找到的就是a。

7.字符指针

在指针的类型中我们知道有一种指针类型为字符指针char*。

一般使用：

#include<stdio.h>
int main()
{
char ch = 'a';
char *pc = &ch;
*pc = 'b';
return 0;
}

还有一种使用的方法是这样的：

#include<stdio.h>
int main()
{
const char *pstr = "hello";//常量字符串不能修改，应该用const修饰的指针来储存。
printf("%s",pstr);
return 0;
}

那这里是把一个字符串放到指针中了吗？

答案是没有的。这里的常量字符串相当于一个数组名字，所以相当于只把其首元素的地址即h的地址储存到了指针中，printf后面的pstr储存了字符串首元素的地址，相当字符串数组的名字，然后就将整个字符串打印出来了。

有了上面的认知，让我们来做这样一道题：

#include<stdio.h>
int main()
{
char str1[] = "abcdef";
char str2[] = "abcdef";

if(str1 == str2)
printf("1");

const char *pstr1 = "abcdef";
const char *pstr2 = "abcdef";

if(pstr1 == pstr2)
printf("2");

return 0：
}

有了之前的认知，我相信这道题对大家来说是不太困难的，程序的输出结果是2。

原因就是这里的pstr1和pstr2指向的都是同一个常量字符串的首元素，C/C++会把常量字符串存储到一个单独的内存区域，当几个指针都指向同一个字符串的时候，他们实际上指向的是同一块内存，但用相同的常量字符串去初始化不同的数组的时候，他们本质上还是不同的数组，所以str1和str2不同，而pstr1和pstr2是相同的。

8.指针数组

讲这个部分之前有一个语文上的问题，指针数组到底是指针还是数组呢？

本质上这是数组的一种，里面存放的是指针，就和整形数组，字符数组里面存放的是整形和字符是一个意思。

int *arr1[5];
char *arr2[3];

上面这两条语句中是什么意思呢？

第一个就是有一个存放5个整形指针的数组。

第二个就是有一个存放3个字符指针的数组。

9.数组指针

9.1数组指针的定义

那么数组指针就显而易见了，这本质上是一种指针，是一种能够指向数组的指针。

下面的代码表达的各是什么含义呢

int *p1[10];
int (*p2)[10];

在解释之前，我们要知道的一个前置知识是[ ]的优先级是要比*高的。

第一个p1会先和[ ]结合，说明它本质上是一个数组，一共有十个元素，那么每个元素是什么类型呢，去除p1[10]之后，就是int*。

第二个p2会先和（）中的*结合，说明他本质上是一个指针，那么它指向的是什么呢，同理，去除（*p1）之后，就是int [10]，即一个有十个元素的一个整形数组。

9.2&数组名和数组名

这个我在上面“指针和数组”的时候曾讲到过这二者的差别，由于下面还会使用到这里的知识，如果有些遗忘建议大家去上面复习一下。

9.3数组指针的使用

那数组指针是怎么使用的呢？

既然数组指针指向的是数组，那数组指针中存放的一个是数组的地址。

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
    return 0;
}

下面是在打印一维数组和二维数组的一些实例，我相信大家在这段学习之后经过自己的慢慢分析是可以理解的：

void print1(int arr[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

void print2(int *arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(arr+i));
	}
	printf("\n");
}

void print3(int(*p)[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", (*p)[i]);//arr;
	}
	printf("\n");
}

void test1()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);

	print1(arr, sz);
	print2(arr, sz);
    print3(&arr, sz);
}

void print4(int arr[3][5], int r, int c)
{		 
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

void print5(int (*p)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ",*(*(p + i) + j));
		}
		printf("\n");
	}
}

void test2()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	print4(arr, 3, 5);
	print5(arr, 3, 5);
}

int main()
{
	test1();
	test2();
	return 0;
}

test1是一维数组的打印，其中print1和print2是使用了传统的一维数组和指针作为形参接受的参数，print3则使用数组指针接受参数，解引用后相当于一个数组名，加上后面[ i ]，就相当于arr[ i ]。显然，我们可以发现，在一维数组的传参中，使用数组指针反而是加大了代码的复杂程度并且减少了可读性。

test2是二维数组的打印，其中print4是传统的使用二维数组作为形参接受参数，而print5是使用了数组指针接受参数。

*(*(p + i) + j)解析：因为p是一个数组指针，步长就是这个二维数组的列数，+i 就相当与找到了该二维数组的第 i 行，解引用之后就相当于数组名即arr[ i ]，数组名相当于首元素的地址，这是一个一维整形数组，所以步长是一个int，首元素的地址就相当于arr[ i ][ 0 ]的地址，+j就相当与arr[ i ][ j ]的地址，然后解引用就找到了arr[ i ][ j ]。

知道了上面的知识，让我们来辨别一下下面这几行代码的意思：

int arr[5];         //含有5个整形的数组
int *parr1[10];     //parr1先和[]结合，本质上是一个数组，含有10个int*的指针
int (*parr2)[10];   //parr2先和*结合，本质上是一个指针，指向的是一个含有10个整形的数组
int (*parr3[10])[5];//parr3先和[]结合，本质是一个数组，数组中含有10个元素，每个元素都是int(*)[5]即数组指针，指向的是含有5个元素的整形数组

10.数组传参和指针传参

10.1一维数组传参

下面是一维数组的几种传参方式，大家来判断一下正确与否

#include <stdio.h>
void test(int arr[])      //ok?
{}
void test(int arr[10])    //ok?
{}
void test(int *arr)       //ok?
{}
void test2(int *arr[20])  //ok?
{}
void test2(int **arr)     //ok?
{}
int main()
{
 int arr[10] = {0};
 int *arr2[20] = {0};
 test(arr);
 test2(arr2);
}

test是传普通的一维整形数组。

第一种和第二种：int arr[ ]，int arr[10]显然都是正确的，因为我们之前讲到在一维数组传参中，本质上是使用一个指针接受，所以[]中的值写不写都是一样的。

第三种：int * arr显然也是正确的，这里就不再赘述。

test2是传一个一维指针数组。

这个数组里面的元素都是int*型的指针，第一种（int *arr[]）可以使用一样的一维指针数组接受参数，第二种（int **arr）就是使用一个二级指针做形参，第一次解引用找到的是这个指针数组中的元素，第二次解引用找到的就是这个指针指向的元素。

10.2二维数组传参

下面是使用数组作为形参

void test(int arr[3][5])//ok？ YES
{}
void test(int arr[][])  //ok？ NO
{}
void test(int arr[][5]) //ok？ YES
{}

二维数组传参是如果形参是数组，和二维数组的初始化一样，可以不知道有多少行，但是一定要写清楚列是多少，这样才方便运算。

下面是使用指针作为形参

void test(int *arr)     //ok？ NO
{}
void test(int* arr[5])  //ok？ NO
{}
void test(int (*arr)[5])//ok？ YES
{}
void test(int **arr)    //ok？ NO
{}

这里使用一个数组指针接受参数是最合适的，其他的都很不合乎逻辑，这块不是很难，希望大家多理解一下。

10.3一级指针传参

这里我们讨论的是如果使用一级指针接收参数即作为形参，那它对应的实参有什么类型：

可以是地址，数组名（首元素地址），指针。这里比较简单，我就不做太多赘述。

10.4二级指针传参

这里同样讨论的是，如果使用二级指针作为形参，对应的实参有什么类型：

可以是二级指针，一级指针的地址，指针数组的数组名（首元素的地址）。

11.函数指针

在讲这个内容之前需要补充一个知识，让我们来看下面这段代码：

#include <stdio.h>
void test()
{
 printf("hehe\n");
}
int main()
{
 printf("%p\n", test);
 printf("%p\n", &test);
 return 0;
}

代码输出的结果是一样的，并且都是函数的地址。

那如果我们函数的地址想要保存起来需要用什么方法呢？答案是函数指针。

我们再来看下面这段代码：

void (*pfun1)();
void *pfun2();

这两个分别是什么意思呢？

首先，()的优先级是要比*高的。

pfun2会先和()结合，所以pfun2是一个函数，返回类型是int*。

pfun1先和*结合，所以pfun1是一个指针，指向的是一个返回类型为int的函数

下面我们再来解析一下下面这两段代码

(*(void (*)())0)();

把0直接转化成一个void(*)()的函数指针，然后再去调用0地址处的函数。

void (*signal(int , void(*)(int)))(int)

上面的代码是一次函数声明

声明的函数是signal

函数的第一个参数是int

函数的第二个参数是一个函数指针，指向的函数参数是int，返回类型是void

signal的返回类型也是一个函数指针，指向的函数的参数是int，返回类型是void

我们发现参数是int，返回类型是void的函数出现了两次，为了简化它我们可以用typede重新定义一种变量类型，就像下面的代码一样：

typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

12.函数指针数组

如果我们想把函数的地址都存到一个数组中去，那么这个数组就叫函数指针数组，那函数指针数组该如何定义呢？

假设我们要存放的函数都是无参数且返回类型是int的函数，数组名字叫parr。

首先函数指针数组是一个数组，所以函数名应该先和[]结合，又因为里面存放的是函数指针，即int (*)()，然后将他们组装起来就是int (*parr[])()。

注意：[ ]的优先级比*高。

函数指针的用途：转移表。

例子：计算机：

#include <stdio.h>
int add(int a, int b)
{
 return a + b;
}
int sub(int a, int b)
{
 return a - b;
}
int mul(int a, int b)
{
 return a*b;
}
int div(int a, int b)
{
 return a / b;
}
int main()
{
 int x, y;
 int input = 1;
   int ret = 0;
     int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
     while (input)
     {
          printf( "*************************\n" );
          printf( " 1:add           2:sub \n" );
          printf( " 3:mul           4:div \n" );
          printf( "*************************\n" );
          printf( "请选择：" );
      scanf( "%d", &input);
          if ((input <= 4 && input >= 1))
         {
          printf( "输入操作数：" );
              scanf( "%d %d", &x, &y);
              ret = (*p[input])(x, y);
         }
          else
               printf( "输入有误\n" );
          printf( "ret = %d\n", ret);
     }
      return 0;
}

13.指向函数指针数组的指针

指向函数指针数组的指针本质上是一个指针，指向的是一个数组，数组的元素都是函数指针。

void test(const char* str)
{
 printf("%s\n", str);
}
int main()
{
 //函数指针pfun
 void (*pfun)(const char*) = test;
 //函数指针的数组pfunArr
 void (*pfunArr[5])(const char* str);
 pfunArr[0] = test;
 //指向函数指针数组pfunArr的指针ppfunArr
 void (*(*ppfunArr)[5])(const char*) = &pfunArr;
 return 0;
}

14.回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

首先我们来介绍一下qsort函数，这是cplusplus网站上对于qsort函数的英文解释及其翻译过后的内容（我是用网页上自带的翻译，会有些不准确，大家见谅）：

首先我们来演示一下qsort函数是如何使用的：

#include <stdio.h>
#include <stdlib.h>
//qosrt函数的使用者得实现一个比较函数
int int_cmp(const void * p1, const void * p2)
{
  return (*( int *)p1 - *(int *) p2);
}
int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    int i = 0;
    
    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
    for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
   {
       printf( "%d ", arr[i]);
   }
    printf("\n");
    return 0;
}

使用回调函数，运用冒泡的方式模拟实现qsort函数：

#include <stdio.h>
#include <stdlib.h>
int int_cmp(const void * p1, const void * p2)
{
  return (*( int *)p1 - *(int *) p2);
}
void _swap(void *p1, void * p2, int size)
{
    int i = 0;
    for (i = 0; i< size; i++)
   {
        char tmp = *((char *)p1 + i);
       *(( char *)p1 + i) = *((char *) p2 + i);
       *(( char *)p2 + i) = tmp;
   }
}
void bubble(void *base, int count , int size, int(*cmp )(void *, void *))
{
    int i = 0;
    int j = 0;
       for (i = 0; i< count - 1; i++)
   {
       for (j = 0; j<count-i-1; j++)
       {
            if (cmp ((char *) base + j*size , (char *)base + (j + 1)*size) > 0)
           {
               _swap(( char *)base + j*size, (char *)base + (j + 1)*size, size);
           }
       }
   }
}
int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    //char *arr[] = {"aaaa","dddd","cccc","bbbb"};
    int i = 0;
    bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
    for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
   {
       printf( "%d ", arr[i]);
   }
    printf("\n");
    return 0;