C语言---指针进阶

物理系的hhpp

已于 2023-03-25 10:47:26 修改

阅读量1.2k

点赞数

文章标签： c语言开发语言后端

于 2022-03-16 15:17:04 首次发布

本文链接：https://blog.csdn.net/weixin_62436283/article/details/123261295

版权

指针的概念：
1. 指针就是个变量(指针变量)，用来存放地址，地址唯一标识一块内存空间。
2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。
3. 指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。
4. 指针的运算。（+-指针(整数)；关系运算）

1.字符指针

#include<stdio.h>
int main()
{
	const char* p = "abcdef";

}
#include <stdio.h>
int main()
{
	char str1[] = "hello bit.";
	char str2[] = "hello bit.";
	const char* str3 = "hello bit.";
	const char* str4 = "hello bit.";
	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;
}

2. 指针数组

int main()
{
	int data1[] = { 1,2,3,4,5 };
	int data2[] = { 2,3,4,5,6 };
	int data3[] = { 3,4,5,6,7 };
	//arr就是一个指针数组
	int* arr[3] = { data1 ,data2, data3 };//存入各个数组的首元素的地址
	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;
}

3.数组指针

3.1 数组指针的定义

int (*p)[10];
//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合

int(*p)[10] = &arr;
p是一个指针，指向了数组，所以p为数组指针

int* arr[10];

int* (*p)[10] = &arr;

//首先arr为指针故建立*p，而存储的类型也是指针型故应如上创建

3.2 &数组名VS数组名

数组名怎么理解？

通常情况下我们所说的数组名都是首元素地址；

两个例外1.sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小；

2.&数组名，这里的数组名表示整个数组，这里表示取出其中整个数组的地址，&数组指向的是数组的最后一个地址

3.3 数组指针的使用

int arr[5];
//arr为整型数组，每个元素是int类型，有5个元素
int* parr1[10];
//parr1是一个数组，数组10个元素，每个元素的类型为int*型
int(*parr2)[10];
//part2是一个指向数组的指针，指向的数组有十个元素，每个元素类型为int型
int(*parr3[10])[5];
//parr3是一个数组，数组中有10个元素，每个元素的类型使：int(*)[5]
//parr3是存放数组指针的数组

int(*parr3[10])[5];

4. 数组参数、指针参数

4.1 一维数组传参

/*（1）*/void test(int arr[])
{}
/*（2）*/void test(int arr[10])
{}
/*（3）*/void test(int* arr)
{}
//一、二和三在本质上一致
/*（4）*/void test2(int* arr[20])
{}
/*（5）*/void test2(int** arr)
{}
//二阶指针，四和五一致
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

4.2 二维数组传参

int main()
{
	int arr[3][5] = { 0 };
	test(arr);//传过去首元素地址
}
二级指针是用来存放一级指针的地址

数组指针是用来存放数组的地址的

而上面主函数中传入的为首行一维数组地址，五个元素的第一行

//三种定义数组

4.3 一级指针传参

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
void test1(int (*p)[5])
{}

4.4 二级指针传参

函数应该为char [*p](5);

在二维数组传参中，传过去的是首元素的地址即二维数组首行地址，地址应用一维指针接受；故题中选取二维指针是错误的。
void test1(int (*p)[5])
{}
void test2(int(*p)[3][5])//指针数组
{
	*p;
}
int main()
{
	int arr[3][5];
	test1(arr);//传递的第一行的地址
	test2(&arr);//传递的是整个二维数组的地址
	return 0;
}

下面代码中print_arr函数参数设计哪个是正确的？（ ）
int arr[3][5] = {1,2,3,4,5,6,7,8,9,10};
print_arr(arr, 3, 5);
A.void print_arr(int arr[][],int row, int col);
B.void print_arr(int* arr, int row, int col);
C.void print_arr(int (*arr)[5], int row, int col);
D.void print_arr(int (*arr)[3], int row, int col);
二维数组相当于数组的数组，传到子函数变成数组的指针。int arr[3][5]相当于是3个元素的arr，每个元素是int [5]，所以int [5]是类型说明不能省略。丢失的信息只有数组的元素个数，也就是3。A丢了类型中的5，B选项指针层级都错了，D选项5写成了3，故选C。

5. 函数指针---指向函数的指针

#include <stdio.h>
void test()
{
	printf("hehe\n");
}
int main()
{
	printf("%p\n", test);
	printf("%p\n", &test);
	return 0;
}
//对于函数来说这俩一致
//均指向函数的地址
//对于数组来讲不一致
//数组中arr为数组的地址
//&arr为数组首元素地址

如何调用？
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int (* pf)(int, int) = Add;//就是函数指针变量
	int ret = (*pf)(2,3);//*其实并无作用
	//int ret = Add(2, 3);
	//int ret = pf(2, 3);
	printf("%d\n", ret);
	//int (*pt)(char*) = test;
	return 0;
}
有趣的代码：
void (*signal(int , void(*)(int)))(int);

signal是一个函数的声明
signal函数的参数，第一个是int类型的，第二个是void(*)(int)的函数指针类型
signal函数的返回值类型也是：void(*)(int)的函数指针

typedef void(* pf_t)(int) ;//给函数指针类型void(*)(int)重新起名叫：pf_t
pf_t signal(int, pf_t);

设有以下函数void fun(int n,char *s){……},则下面对函数指针的定义和赋值均是正确的是：（ ）
A.void (*pf)(int，char); pf=&fun;
B.void (*pf)(int n，char *s); pf=fun;
C.void *pf(); *pf=fun;
D.void *pf(); pf=fun;
CD前半句压根就不是定义而是声明，A选项参数列表的第二个参数错了。应为char *，B选项正确。需要说明的是，对于函数名来说，前面的&和*都会被忽略，所以fun前面加不加取地址都没区别。只有定义出的函数指针变量（如题面中的pf）加上&后才会变成二级函数指针。

6.函数指针数组

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;
}
int main()
{
	//指针数组
	//字符指针数组
	char* arr[5];

	//整形指针数组
	int* arr2[4];
	
	//int (*pf1)(int, int) = Add;
	//int (*pf2)(int, int) = Sub;
	//int (*pf3)(int, int) = Mul;
	//int (*pf4)(int, int) = Div;

	//函数指针数组
	int (* pf[4])(int, int) = { Add, Sub, Mul, Div };

	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int ret = pf[i](8, 2);
		printf("%d\n", ret);
	}

	return 0;
}

pf [i]//指第i个函数 (8,2)//支赋值为8和2

pf 先和[] 结合，说明 pf是数组，数组的内容是什么呢？
是 int (*)() 类型的函数指针。

函数指针作用->转移表

弊端：所合并的函数需要使函数类型一致

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

指向函数指针数组的指针是一个：指针
指针指向一个数组，数组的元素都是：函数指针

套娃

#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;
}
int main()
{
	//函数指针数组
	int (*pfarr[4])(int, int) = {Add,Sub,Mul,Div};
	int (*(* p3)[4])(int, int) = &pfarr;//p3是一个指向函数指针数组的指针
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		
		int ret = (*p3)[i](3,4);
		printf("%d\n", ret);
	}
	return 0;
}

比较此代码与上方代码

8. 回调函数

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

对计算器代码的优化

将switch循环的代码利用回调函数来优化

（1）利用指针函数来将其中的switch语句所需代码存在calc中，利用calc作为回调函数

（2）再利用pf间接指向各个函数，来做统一规划

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");
}

void calc(int (*pf)(int,int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("请输入2个操作数:>");
	scanf("%d%d", &x, &y);
	ret = pf(x, y);
	printf("ret = %d\n", ret);
}
int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(Add);
			break;
		case 2:
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

qsort是一个库函数

基于快速排序算法实现的一个排序的函数

void qsort( void *base（排序目标，待排序的起始位置）, size_t num（数组元素个数）, size_t width（一个元素字节的大小）, int (__cdecl *compare )（比较函数）(const void *elem1, const void *elem2 ) (elem1，2待比较的元素地址); //来源MSDN

qosrt函数要求使用者得自定义实现一个比较函数

如：int int_cmp(const void* p1, const void* p2)

（1）排序的整形数据：用>，<

（2）排序的结构体数据可能不方便直接使用>，<比较

（3）使用者根据实际创建函数进行比较

#include <stdio.h>
int int_cmp(const void* p1, const void* p2)//void*可以任意存入数据，但会导致无法明确其类型下方
{                                            无法直接使用*p1进行直接解引用，所以要在下方强制转
                                             换为对应所需要的形式。
	return (*(int*)p1 - *(int*)p2);
}//强制转换为int*
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;
}
//比较整形数据

struct Stu
{
	char name[20];
	int age;
	double score;
};
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);//比较字符串用的就是 
                                                                    strcmp
}
//e1和e2换位置就是降序
void test3()
{
	struct Stu arr[3] = { {"zhangsan", 20, 55.5},{"lisi", 30, 88.0},{"wangwu", 10, 90.0} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
	test5();
	return 0;
}
//使用qsort排序结构体

冒泡排序的优化：模拟qsort函数的冒泡函数

#include<stdio.h>
#include <stdlib.h>
int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);
}
void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void bubble_sort(void* base, int num, int width, int (*cmp)(const void* e1, const void* e2))
{                     //不明确起始位置                       //参数，const修饰后不能更改，void*不明确类型
	int i = 0;
	for (i = 0; i < num - 1; i++)
	{
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//if (arr[j] > arr[j + 1])//比较
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				//交换
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}
void test4()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//排序为升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
}
int main()
{
	test4();
	return 0;
}

一段对冒泡排序法其中的细节的详解

void myqsort(void * base, size_t nitems, size_t size, int(*compar)(const void *, const void *))
{
	int i, j;
	char * st = (char *)base; //void *不方便加减，用char *加减轻松且字节跳转为1，方便控制。
	char tmp[16]; //考虑到long double类型，临时空间做成16字节比较保险
 
	for (i = 0; i < nitems - 1; i++)
	{
		for (j = 0; j < nitems - 1 - i; j++) //冒泡常用循环头
		{
			if (compar(st + j * size, st + (j + 1) * size)) //比较的时候跳转注意乘size
			{
				memcpy(tmp, st + j * size, size); //交换操作用memcpy完成就不会出问题。
				memcpy(st + j * size, st + (j + 1) * size, size);
				memcpy(st + (j + 1) * size, tmp, size);
			}
		}
	}
}

9.指针的题目

1.数组名的意义：

int main()
{
	int a[] = { 1,2,3,4 };
	           /*0 1 2 3*/
	int(*p)[4] = &a;
	printf("%d\n", sizeof(a));//4*4 = 16
	printf("%d\n", sizeof(a + 0));//4/8 a+0是数组第一个元素的地址，是地址，大小就是4/8个字节
	printf("%d\n", sizeof(*a)); //4 a表示数组首元素的地址，*a表示数组的第一个元素，sizeof(*a)就是第一个元素的大小-4
	printf("%d\n", sizeof(a + 1));//4/8 a表示数组首元素的地址，a+1数组第二个元素的地址，sizeof(a+1)就是第二个元素的地址的大小
	printf("%d\n", sizeof(a[1]));//4 计算的是第二个元素的大小
	printf("%d\n", sizeof(&a));//4/8 &a取出的是数组的地址，数组的地址也是地址呀，是地址大小就是4/8字节
	printf("%d\n", sizeof(*&a));//16 计算的整个数组的大小 
	printf("%d\n", sizeof(&a + 1));//4/8 - &a是数组的地址，+1跳过整个数组，产生的4后边位置的地址
	printf("%d\n", sizeof(&a[0]));//4/8 取出的数组第一个元素的地址
	printf("%d\n", sizeof(&a[0] + 1));//4/8 数组第二个元素的地址
	//字符数组
	char arr[] = { 'a','b','c','d','e','f' };//[a b c d e f]
	printf("%d\n", strlen(arr));//随机值，arr数组中没有\0，所以strlen函数会继续往后找\0，统计\0之前出现的字符个数
	printf("%d\n", strlen(arr + 0));//随机值，arr+0还是数组首元素的地址
	//printf("%d\n", strlen(*arr));//err - arr是数组首元素的地址，*arr是数组的首元素，‘a’-97 但strlen要的是一个地址
	//printf("%d\n", strlen(arr[1]));//err -'b' - 98
	printf("%d\n", strlen(&arr));//随机值
	printf("%d\n", strlen(&arr + 1));//随机值
	printf("%d\n", strlen(&arr[0] + 1));//随机值
}

    char* p = "abcdef";
	printf("%d\n", strlen(p));//6
	printf("%d\n", strlen(p + 1));//5 从b的位置开始向后数字符
	//printf("%d\n", strlen(*p));  //err
	//printf("%d\n", strlen(p[0]));//err
	printf("%d\n", strlen(&p));//随机值，取出p的地址，在p的地址上向后移动
	printf("%d\n", strlen(&p + 1));//随机值
	printf("%d\n", strlen(&p[0] + 1));//5  从b的位置开始向后数字符

	printf("%d\n", sizeof(p));//4/8  p是指针变量，计算的是指针变量的大小
	printf("%d\n", sizeof(p + 1));//4/8 p+1是'b'的地址
	printf("%d\n", sizeof(*p)); //1  - *p 其实就是'a'
	printf("%d\n", sizeof(p[0]));//1 - p[0]-> *(p+0)-> *p
	printf("%d\n", sizeof(&p));//4/8 &p 是指针变量p在内存中的地址
	printf("%d\n", sizeof(&p + 1));//4/8 - &p+1是跳过p之后的地址
	printf("%d\n", sizeof(&p[0] + 1));//4/8 &p[0]是‘a’的地址，&p[0]+1就是b的地址

//二维数组
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//计算的是整个数组的大小，单位是字节3*4*4 = 48
	printf("%d\n", sizeof(a[0][0]));//4 第1行第一个元素的大小
	printf("%d\n", sizeof(a[0]));//16 - a[0]是第一行的数组名，sizeof(a[0])就是第一行的数组名单独放在sizeof内部，计算的是第一行的大小
	printf("%d\n", sizeof(a[0] + 1));//4/8 a[0]作为第一行的数组名，并没有单独放在sizeof内部，也没有被取地址
	//所以a[0]就是数组首元素的地址，就是第一行第一个元素的地址，a[0]+1就是第一行第二个元素的地址
	printf("%d\n", sizeof(*(a[0] + 1)));//4 - *(a[0] + 1))表示的是第一行第二个元素
	printf("%d\n", sizeof(a + 1));//4/8 - a表示首元素的地址，a是二维数组，首元素的地址就是第一行的地址
	//所以a表示的是二维数组第一行的地址，a+1就是第二行的地址，地址就是4/8个字节长度
	printf("%d\n", sizeof(*(a + 1)));//16 对第二行的地址解引用访问到就是第二行
	//*(a+1) -> a[1]指向第二行的元素
	//sizeof(a[1])
	printf("%d\n", sizeof(&a[0] + 1));//4/8 - a[0]是第一行的数组名，&a[0]取出的就是第一行的地址
	//&a[0] + 1 就是第二行的地址
	printf("%d\n", sizeof(*(&a[0] + 1)));//16 - 对第二行的地址解引用访问到就是第二行
	printf("%d\n", sizeof(*a));//16 - a就是首元素的地址，就是第一行的地址，*a就是第一行
	//*a - > *(a+0) -> a[0]
	printf("%d\n", sizeof(a[3]));//16 int [4]
	//int a = 10;
	//printf("%d\n", sizeof(a));//4
	//printf("%d\n", sizeof(int));//4
	return 0;
}

总结：

1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
2. & 数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
3. 除此之外所有的数组名都表示首元素的地址。
4.sizeof是一个操作符
5.sizeof 计算的是对象所占内存的大小 - 单位是字节, size_t不在乎内存中存放的是什么，只在乎内存大小
6.strlen是一个库函数
7.求字符串长度，从给定的地址向后访问字符，统计\0之前出现的字符个数
8.对于二维数组可想象成每一行都是一维数组

struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
	printf("%p\n", p + 0x1);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}

（1）p直接加上一个0x1表示加上一个结构体大小：20，表示为0x10016
（2）p转化为整型，整型加一就是加一
（3）p转化为指针，指针加一就是加上一个指针大小为4

前篇： C语言----初阶指针

物理系的hhpp

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C语言---指针进阶

目录1.字符指针2. 指针数组3.数组指针3.1 数组指针的定义3.2 &数组名VS数组名3.3 数组指针的使用4. 数组参数、指针参数4.1 一维数组传参4.2 二维数组传参4.3 一级指针传参4.4 二级指针传参5. 函数指针---指向函数的指针6.函数指针数组7. 指向函数指针数组的指针8. 回调函数9.指针的题目
复制链接

扫一扫