【C 语言进阶】一篇文章将你的 C 语言指针升华

其他 2021-11-16 13:35:42 阅读次数: 0

文章目录


指针的一些基础知识我已经在 【初阶指针】这章总结过了，如果大家有些地方不清楚，可以点击链接回过去看一下。【初阶指针】了解后，我们了解了指针的概念：

  1. 指针就是个变量，用来存放地址。地址可以唯一标识一块内存空间
  2. 指针的大小是固定的4/8个字节（32位平台/64位平台）
  3. 指针是有类型的。指针的类型决定了指针加减整数的步长，指针解引用操作时访问字节的大小
  4. 指针的运算方式

而这章我们将更深入的探索指针的其他奥秘。

1. 字符指针

定义

字符指针是指向字符的指针，char*

用法

字符指针通有两种用法：

用法一：指针指向一个字符

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

用法二：指针指向一个字符串

指针存入的是字符串首字符的地址

#include <stdio.h>
int main()
{
    
    
	char* pc = "hello world!";//将字符串首字符'h'地址放入pc

	printf("%c\n", *pc);//结果为：h
	printf("%s\n", pc);//结果为：hello world!
	return 0;
}

接下来看一个练习：

#include <stdio.h>
int main()
{
    
    
	char str1[] = "hello world!";
	char str2[] = "hello world!";
	const char* str3 = "hello world!";
	const char* str4 = "hello world!";

	if (str1 == str2)
		printf("str1 and str2 are same\n");
	else
		printf("str1 and str2 are not same\n");
	if(str3 == str4)
		printf("str3 and str4 are same\n");
	else
		printf("str3 and str4 are not same\n");
	return 0;
}
//结果为：
//str1 and str2 are not same
//str3 and str4 are same

在这里插入图片描述

2. 指针数组

定义

  • 指针数组，本质还是数组
  • 数组其实已经有整型数组，字符数组，而指针数组也是一样的，是存放指针的数组
int arr[10];//整型数组——存放整型的数组
char ch[5];//字符数组——存放字符的数组

//指针数组——存放指针的数组
int* parr[5];//整型指针数组，有五个元素，每个元素是一个整形指针

用法

用法一：

#include <stdio.h>
int main()
{
    
    
	int a = 10;
	int b = 20;
	int c = 30;
	int* arr[3] = {
    
     &a, &b, &c };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
    
    
		printf("%d ", *arr[i]);
	}
	return 0;
}

不推荐上面使用的方法，毕竟是多此一举啦

用法二：

#include <stdio.h>
int main()
{
    
    
	int a[5] = {
    
     1,2,3,4,5 };
	int b[5] = {
    
     2,3,4,5,6 };
	int c[5] = {
    
     3,4,5,6,7 };
	int* arr[3] = {
    
     a,b,c };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
    
    
		int j = 0;
		for (j = 0; j < 5; j++)
		{
    
    
			printf("%d ", *(arr[i] + j));
		}
		printf("\n");
	}
	return 0;
}
  • 输出函数也可以写成：printf("%d ", arr[i] [j]);
  • 如果不知道推导的可以去看看初阶指针这章，在数组和地址的关系那部分有进行讲解

3. 数组指针

定义

数组指针，本质是指针，是指向数组的指针

补充

  • 一维数组arr的地址是：&arr，如果+1跳过的是整个数组大小
  • 一维数组名arr一般是数组首元素的地址，等价于&arr[0]，如果+1，跳过的是一个元素的大小
  • 二维数组数组名表示首元素地址，而二维数组首元素实则是第一行，并非第一个元素
#include <stdio.h>
int main()
{
    
    
	int arr[5] = {
    
     1,2,3,4,5 };
	int (*parr)[5] = &arr;
	return 0;
}

而如果将代码改成：int *parr[5] = &arr; 表示的还是数组指针吗？NO！

  • 因为[]的优先级要高于 * 号，所以必须加上（）来保证parr先和 * 结合，只有 * 和parr结合才能说明parr是一个指针。
  • 而若不加*，parr[5]结合，表示的是一个数组，故这里就是指针数组而不是数组指针

练习：将指向double* a[5];的指针写出来

double* (*pa)[5];

因为a[5]是一个数组，每个元素都是double*类型，故是一个指针数组。指针为( *pa )，而它指向的是一个数组( *pa )[5]，而每个元素都是double * 类型的，故结果为：double* (*pa)[5];

注意

数组名一般是数组首元素的地址，但有两种情况例外：

  1. sizeof(数组名)——数组名表示整个数组，计算的是整个数组大小，单位是字节
  2. &数组名——数组名表示整个数组，取出的是整个数组的地址

用法

练习一：用一维数组数组地址输出元素值（平常一般不使用这种方法）

#include <stdio.h>
int main()
{
    
    
	int arr[5] = {
    
     1,2,3,4,5 };
	int(*pi)[5] = &arr;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
    
    
		printf("%d ", *(*pi+i));
	}

	return 0;
}

我们可以知道*pi其实就是数组名，而数组名表示了数组首元素的地址，（ *pi+i ）则表示数组每个元素的地址，再通过解引用就是每个元素的值

练习二：写一个函数接收二维数组地址输出元素值

void print2(int(*p)[5], int row, int col)
{
    
    
	int i = 0;
	for (i = 0; i < row; i++)
	{
    
    
		int j = 0;
		for (j = 0; j < col; j++)
		{
    
    
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
}
int main()
{
    
    
	int arr[3][5] = {
    
     {
    
    1,2,3,4,5},{
    
    6,7,8,9,10},{
    
    11,12,13,14,15} };
	print2(arr, 3, 5);
	return 0;
}

在这里插入图片描述

练习三：判断int(*parr[10])[5];的parr是什么？

parr是一个存放数组指针的数组。该数组能存放十个数组指针。每个数组指针能够指向一个数组，该数组有五个元素，每个元素是int类型

4. 数组传参和指针传参

在写代码时你是否经常碰到将【数组】或者【指针】传给函数，那么函数的参数该怎么设计呢？下面分别取一维数组、二维数组、一级指针、二级指针传给函，梳理出一些正确以及错误的方式

一维数组

#include <stdio.h>
void test(int arr[])//可以
{
    
    }
void test(int arr[10])//可以
{
    
    }
void test(int *arr)//可以，因为一维数组名就是数组首元素的地址
{
    
    }
void test2(int *arr[20])//可以
{
    
    }
void test2(int **arr)//可以
{
    
    }
int main()
{
    
    
	int arr[10] = {
    
     0 };//整型数组
	int *arr2[20] = {
    
     0 };//指针数组
	test(arr);
	test2(arr2);
	return 0;
}

为什么test2的第二种可以呢？首先我们要知道指针数组他的每个元素都是一个指针，而数组名是数组首元素的地址，故传过去的就是第一个指针的地址，而二级指针可以存放指针的地址

二维数组

void test(int arr[3][5])//可以
{
    
    }
void test(int arr[][])//不可以，因为二维数组列的大小必须要写，行的大小可以省略
{
    
    }
void test(int arr[][5])//可以
{
    
    }
void test(int *arr)//不可以
{
    
    }
void test(int* arr[5])//不可以
{
    
    }
void test(int (*arr)[5])//可以
{
    
    }
void test(int **arr)//不可以
{
    
    }
int main()
{
    
    
 	int arr[3][5] = {
    
    0};
 	test(arr);
    return 0;
}
  • 因为二维数组数组名表示数组第一行的地址，如果单纯用整型指针接收，那么该指针接收到的是个有五个元素数组的地址，而不是首元素的地址。如果用数组指针接收，该指针指指向的就是一个有五个整型元素的的数组，而传过来的就是一个有五个元素数组的地址，刚好存入。
  • 二级指针的话接受的应该是一级指针的地址，而二维数组传过去的是第一行数组的地址，两者不一样

一级指针

#include <stdio.h>
void print(int *p, int sz)//可以
{
    
    
	int i = 0;
	for (i = 0; i < sz; i++)
	{
    
    
		printf("%d\n", *(p + i));
	}
}
int main()
{
    
    
	int arr[10] = {
    
     1,2,3,4,5,6,7,8,9 };
	int *p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(p, sz);
	return 0;
}

二级指针

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

小结

函数形参为一级指针，可以接收哪些参数：

  1. 元素的地址
  2. 一级指针

函数形参为二级指针，可以接收哪些参数：

  1. 二级指针
  2. 一级指针变量地址
  3. 存放一级指针的数组

5. 函数指针

定义

函数指针是指向函数的指针，存放函数地址的指针

用法

首先我们要找到函数的地址，那么函数的地址如何表示呢？

函数的地址其实就是&函数名

#include <stdio.h>
void test()
{
    
    
	printf("hehe\n");
}
int main()
{
    
    
    printf("%p\n", test);
    printf("%p\n", &test);
    return 0;
}
//test和&test地址其实是一样的

知道了函数的地址后怎么写出一个函数指针呢？（引用Add函数）

  1. 首先我们写出一个指针*p=&Add，意思是将函数的地址放入一个指针内
  2. 然后这个指针指向一个函数，所以 *p()=&Add，又因为 () 的优先级更高一点，如果只是这样写的话， p() 结合在一起就是一个函数的形式了，所以要加括号 ( *p )()=&Add
  3. 而这个函数的参数是两个整型，故 ( *p )( int, int )=&Add
  4. 最后我们知道这个函数的返回类型是整型，故最后Add函数的指针为： int ( *p )( int, int )=&Add
  5. 函数的&函数名与函数名都可以代表函数的地址，故Add函数的指针也可以写成： ( *p )( int, int )=Add
#include <stdio.h>
int Add(int a, int b)
{
    
    
	return a + b;
}
int main()
{
    
    
	int a = 2;
	int b = 3;
	int(*p1)(int, int) = &Add;
	int(*p2)(int, int) = Add;
    
	return 0;
}
//两个指针意义一样

那么一个函数指针如何使用呢？

  • 首先我们将函数指针解引用，函数指针解引用其实我们得到的就是函数，再将参数传进去就可以使用函数指针，形式为：(*p)(a, b)
  • 要注意 (*p) 两边的括号不能去掉，因为括号优先级更高，就直接调用函数了
int main()
{
    
    
	int a = 2;
	int b = 3;
	int(*p)(int, int) = &Add;
    int ret=Add(a, b);
	printf("%d\n", ret);
	printf("%d\n", (*p)(a, b));
	return 0;
}
//两个输出结果一样

注意

  1. 函数指针既然可以写成：( *p )( int, int )=Add，说明p == Add
  2. 用函数的写法：ret2=Add(a, b);
  3. 故将Add换成p，则可以写成：ret3=p(a, b);
  4. 故最终我们知道函数指针有两个写法，函数指针使用时解引用那颗星其实是没意义的，甚至你可以再加N个星
int main()
{
    
    
	int a = 2;
	int b = 3;
	int(*p)(int, int) = &Add;
    int ret1=(*p)(a,b);
    int ret2=Add(a, b);
	int ret3=p(a,b);
	return 0;
}

练习

练习一：分析下列代码：

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

其实该行代码就是调用0地址处的函数，那怎么分析呢？

  1. void(*)()，其实就是一个函数指针类型
  2. (void(*)())0，其实就是对0进行强制类型转换，因为函数指针存放的就是个函数地址，所以0被解释为一个函数地址
  3. *(void(*)())0，对0地址进行解引用操作，此时相当于一个函数
  4. *(void(*)())0()，再将函数参数放入，即是调用0地址处的函数

练习二：分析下列代码：

void (*signal(int , void(*)(int)))(int);
  1. 从signal(int , void(*)(int))可以知道signal是一个函数名，函数的第一个参数是整型，第二个参数是一个函数指针类型，该函数指针指向一个参数为int，返回类型是void的函数
  2. 将signal(int , void(*)(int))从原式挖去后，得到的是void (*)(int)，这是一个函数指针类型
  3. 故signal的返回类型也是一个函数指针，该函数指针指向一个参数为int，返回类型是void的函数。故signal是一个函数的声明

以上代码其实可以换一种形式去理解

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

这种形式的理解就是：有一个signal的函数，其返回值为void (*)(int)。

但是这种形式的语法是不支持的。因为如果这个函数的返回类型是一个指针的话，那么就要将signal(int,void(*)(int))那部放到(*)里面

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

然而我们可以借用typedef对类型进行重定义，使得语法可以被支持

//对void(*)(int)的函数指针类型重命名为pfun_t
typedef void(*pfun_t)(int);

pfun_t signal(int,pfun_t);

小结

  1. 函数指针有两种写法，并且使用时指针前面那颗星是没有意义的

  2. 函数指针可以类比于数组指针。但是函数指针与数组指针有几大不同点：

  1. 数组arr，其数组名等于数组首元素的地址，而&数组名等于数组的地址，arr != &arr。但是函数test（），其函数名与&函数名相等，test == &test
  2. 函数指针指向的是一个函数，故指针后要有(函数参数)，而数组指针后要有[数组大小]
  3. 函数指针的类型是函数的返回类型，而数组指针的类型是数组的类型

6. 函数指针数组

定义

存放函数指针的数组，存放的是同类型的函数指针（返回类型，参数都要相同）

#include <stdio.h>
int Add(int x, int y)
{
    
    
	return x + y;
}
int Sub(int x, int y)
{
    
    
	return  x - y;
}
int main()
{
    
    
	int(*pf1)(int, int) = Add;
	int(*pf2)(int, int) = Sub;、
    //pfArr是一个函数指针数组
	int(*pfArr[2])(int, int) = {
    
     Add, Sub };
	return 0;
}

用法

以一个简单的计算器代码为例：

#include <stdio.h>
int Add(int x, int y)
{
    
    
	return x + y;
}
int Sub(int x, int y)
{
    
    
	return  x - y;
}
int Mul(int x, int y)
{
    
    
	return  x * y;
}
int Div(int x, int y)
{
    
    
	return  x / y;
}
void menu()
{
    
    
	printf("******************************\n");
	printf("****** 1.Add      2.Sub ******\n");
	printf("****** 3.Mul      4.Div ******\n");
	printf("*********** 0.Exit ***********\n");
	printf("******************************\n");
}
int main()
{
    
    
	//计算器——计算整型的加、减、乘、除
	int input = 0;
	do
	{
    
    
		menu();
        //存储计算器的几个简单函数（这里其实相当于一个转移表）
		int(*pfArr[5])(int, int) = {
    
     NULL, Add, Sub, Mul, Div };
		int x, y;
		int ret = 0;
		printf("请选择:>");
		scanf("%d", &input);
		if (input >= 1 && input <= 4)
		{
    
    
			printf("请输入两个操作数:>");
			scanf("%d%d", &x, &y);
			ret = (pfArr[input])(x, y);
			printf("ret=%d\n", ret);
		}
		else if (input == 0)
		{
    
    
			printf("退出程序\n");
			break;
		}
		else
			printf("选择错误,重新选择\n");
	} while (input);
	return 0;
}

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

定义

存放函数指针数组的地址的指针

用法

体验一下下面这段代码：

int(*p1)(int, int);//函数指针
int(*p2[4])(int, int);//函数指针数组
int(*(*p3)[4])(int, int) = &p2;//p3就是一个指向函数指针数组的指针

8. 回调函数

定义

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

用法

我们可以写一个函数：

int Calc(int(*p)(int, int))
{
    
    
	int x, y;
	printf("请输入两个数:>");
	scanf("%d%d", &x, &y);
	return p(x, y);
}
int ret=Calc(Add);

这个Calc函数的参数其实是Add函数的地址，我们在使用Calc函数时，调用了Add函数。所以这种机制就叫做回调函数机制

接下来我们模仿qsort排序实现一个冒泡排序，以便于我们可以对非整型函数实现冒泡排序

#include <stdio.h>
#include <stdlib.h>
void Swap(char* p1, char* p2, int width)//将每个值的每个字节都进行交换
{
    
    
	int i = 0;
	for (i = 0; i < width; i++)
	{
    
    
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
}
void bubble_qsort(void* base, int sz, int width, int(*cmp)(const void *p1, const void *p2))
{
    
    
	int i = 0;
	for (int i = 0; i < sz - 1; i++)//趟数
	{
    
    
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)//每趟排序
		{
    
    
			//两个元素比较
			//用char的原因是不知道数据类型，但我们知道每个字节宽度，故用char将指针单位变为1就可
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
    
    
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}
int cmp_int(const void * p1, const void * p2)
{
    
    
	return (*(int *)p1 - *(int *)p2);
}
void test()
{
    
    
	int arr[] = {
    
     1,3,5,7,9,2,4,6,8,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_qsort(arr, sz, sizeof(int), cmp_int);
	int i = 0;
	for (int i = 0; i < sz; i++)
	{
    
    
		printf("%d ", arr[i]);
	}
}
int main()
{
    
    
	test();
	return 0;
}

其中就是用了回调函数的机制，大家可以自己寻找！

补充（qsort函数）

void qsort(
    void *base,
    size_t num,
    size_t size,
    int (*compar)(const void *, const void *)
    );

//void*：可以存放任意类型 
//base：中存放的是待排序数据中第一个对象的地址
//num：排序数据元素的个数
//size：排序数据中每个元素的大小（字节）
//(*compar)(const void *, const void *)：用来比较待排序数据中的2个元素的函数，决定了排序的顺序(使用者来实现)
  • 功能：qsort()函数可以进行排序，是用了快排的方法
  • 头文件：<stdlib.h>
  • 注意：如果两个元素的值是相同的，那么它们的前后顺序是不确定的。也就是说qsort()是一个不稳定的排序算法

compar参数的返回值决定排序顺序

  1. 如果compar返回值小于0，那么前一个指针所指向元素会被排在后一个指针所指向元素的前面
  2. 如果compar返回值等于0，那么前一个指针所指向元素与后一个指针所指向元素的顺序不确定
  3. 如果compar返回值大于0，那么前一个指针所指向元素会被排在后一个指针所指向元素的后面

看下面一段代码，体悟一下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;
}

再来看一段代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Stu
{
    
    
	char name[20];
	int age;
};
int com_age(const void* p1, const void* p2)
{
    
    
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
void test1()//按照年龄来排序
{
    
    
	struct Stu s[] = {
    
     {
    
    "C",50},{
    
    "Java",25},{
    
    "Python",36} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), com_age);
	for (int i = 0; i < sz; i++)
	{
    
    
		printf("%d ", s[i].age);
	}
}
int com_name(const void* p1, const void* p2)
{
    
    
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
void test2()//按照名字来排序
{
    
    
	struct Stu s[] = {
    
     {
    
    "C",50},{
    
    "Java",25},{
    
    "Python",36} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), com_name);
	for (int i = 0; i < sz; i++)
	{
    
    
		printf("%s ", s[i].name);
	}
}
int main()
{
    
    
	test1();//按照年龄来排序
	printf("\n");
	test2();//按照名字来排序
	return 0;
}

9.总结

本章其实是在之前基础指针那章的基础上对指针更深入的挖掘，其中有的地方主要是希望大家可以理解，并不要求掌握能写的出来。但是我相信，这章的内容你搞懂了，那么指针对你来说已经是小case啦！我是吞吞吐吐鸭，希望我写的内容大家可以喜欢！！！

猜你喜欢

转载自blog.csdn.net/weixin_51367845/article/details/118445418
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022